@nowcrew/daemon 0.6.64 → 0.6.65

package/dist/storage-doctor.js

@@ -0,0 +1,228 @@
+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),
+    });
+}

package/dist/storage-identity.js

@@ -0,0 +1,29 @@
+import { createHash } from "node:crypto";
+import { STORAGE_LAYOUT_VERSION } from "./storage-layout.js";
+function fingerprint(namespace, value) {
+    return `sha256:${createHash("sha256").update(`${namespace}\0${value}`).digest("hex")}`;
+}
+export function storageIdFingerprint(storageId) {
+    return fingerprint("storage", storageId);
+}
+export function storageHelloIdentity(input) {
+    const { installation, layout } = input;
+    if (installation.environment !== layout.environment
+        || installation.workspaceId !== layout.workspaceId
+        || installation.nowworkHome !== layout.persistentRoot
+        || installation.runtimeRoot !== layout.runtimeRoot) {
+        throw new Error("installation storage identity does not match resolved layout");
+    }
+    return Object.freeze({
+        storageLayoutVersion: STORAGE_LAYOUT_VERSION,
+        storageEnvironment: layout.environment,
+        storageWorkspaceId: layout.workspaceId,
+        storageIdFingerprint: storageIdFingerprint(installation.storageId),
+        workspaceRootFingerprint: fingerprint("workspace-root", layout.workspaceRoot),
+        daemonRootFingerprint: fingerprint("daemon-root", layout.daemonRoot),
+        agentRootFingerprint: fingerprint("agent-root", layout.agentItemsRoot),
+        ...(installation.storageMigrationId === undefined
+            ? {}
+            : { storageMigrationId: installation.storageMigrationId }),
+    });
+}

package/dist/storage-layout.js

@@ -0,0 +1,143 @@
+import { realpathSync } from "node:fs";
+import { posix, win32 } from "node:path";
+export const STORAGE_LAYOUT_VERSION = 2;
+const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/iu;
+const ENVIRONMENT = /^[a-z0-9][a-z0-9_-]{0,31}$/u;
+const CONTROL = /[\0\r\n]/u;
+const pathsFor = (platform) => platform === "win32" ? win32 : posix;
+function canonicalExistingAncestor(value, platform) {
+    if (platform !== process.platform)
+        return value;
+    const paths = pathsFor(platform);
+    const missing = [];
+    let ancestor = value;
+    for (;;) {
+        try {
+            return paths.join(realpathSync.native(ancestor), ...missing);
+        }
+        catch (error) {
+            const code = error.code;
+            if (code !== "ENOENT" && code !== "ENOTDIR")
+                throw error;
+        }
+        const parent = paths.dirname(ancestor);
+        if (parent === ancestor)
+            return value;
+        missing.unshift(paths.basename(ancestor));
+        ancestor = parent;
+    }
+}
+function assertSafeText(value, label) {
+    if (value.length === 0 || CONTROL.test(value))
+        throw new Error(`${label} contains empty or control characters`);
+}
+function normalizedAbsolutePath(value, userHome, platform) {
+    assertSafeText(value, "NOWWORK_HOME");
+    const paths = pathsFor(platform);
+    let expanded = value;
+    if (value === "~") {
+        if (userHome === undefined)
+            throw new Error("NOWWORK_HOME '~' requires user home");
+        expanded = userHome;
+    }
+    else if (value.startsWith("~/") || (platform === "win32" && value.startsWith("~\\"))) {
+        if (userHome === undefined)
+            throw new Error("NOWWORK_HOME '~' requires user home");
+        expanded = paths.join(userHome, value.slice(2));
+    }
+    if (!paths.isAbsolute(expanded))
+        throw new Error("NOWWORK_HOME must be absolute or start with '~/'");
+    return canonicalExistingAncestor(paths.normalize(expanded), platform);
+}
+export function validateStorageEnvironment(value) {
+    assertSafeText(value, "storage environment");
+    const normalized = value.trim().toLowerCase();
+    if (normalized === "in" || normalized === "production")
+        return "production";
+    if (!ENVIRONMENT.test(normalized) || normalized.includes("..")) {
+        throw new Error("storage environment must use lowercase letters, digits, '_' or '-'");
+    }
+    return normalized;
+}
+function validateOpaqueId(value, label) {
+    if (!UUID.test(value))
+        throw new Error(`${label} id must be a UUID`);
+    return value.toLowerCase();
+}
+function assertRuntimeIsLocal(persistentRoot, runtimeRoot, platform) {
+    const paths = pathsFor(platform);
+    const relative = paths.relative(persistentRoot, runtimeRoot);
+    if (relative === "" || (!relative.startsWith("..") && !paths.isAbsolute(relative))) {
+        throw new Error("runtime root must not be inside NOWWORK_HOME");
+    }
+}
+export function resolveNowworkHome(input) {
+    const selected = input.explicit !== undefined
+        ? { value: input.explicit, source: "explicit" }
+        : input.environment !== undefined
+            ? { value: input.environment, source: "environment" }
+            : null;
+    if (selected !== null) {
+        return Object.freeze({
+            mode: "standard",
+            root: normalizedAbsolutePath(selected.value, input.userHome, input.platform),
+            source: selected.source,
+        });
+    }
+    return Object.freeze({
+        mode: "legacy",
+        root: normalizedAbsolutePath(pathsFor(input.platform).join(input.userHome, ".crew"), undefined, input.platform),
+        source: "legacy_default",
+    });
+}
+export function resolveEnvTag(input) {
+    if (input.explicit !== undefined) {
+        return Object.freeze({ environment: validateStorageEnvironment(input.explicit), source: "explicit" });
+    }
+    if (input.environment !== undefined) {
+        return Object.freeze({ environment: validateStorageEnvironment(input.environment), source: "environment" });
+    }
+    return Object.freeze({ environment: "production", source: "default" });
+}
+export function storageLayout(input) {
+    const paths = pathsFor(input.platform);
+    const persistentRoot = normalizedAbsolutePath(input.nowworkHome, undefined, input.platform);
+    const runtimeBase = normalizedAbsolutePath(input.runtimeBase, undefined, input.platform);
+    const environment = validateStorageEnvironment(input.environment);
+    const workspaceId = validateOpaqueId(input.workspaceId, "workspace");
+    const environmentRoot = environment === "production"
+        ? persistentRoot
+        : paths.join(persistentRoot, "environments", environment);
+    const workspaceRoot = paths.join(environmentRoot, "workspaces", workspaceId);
+    const runtimeRoot = paths.join(runtimeBase, environment, workspaceId);
+    assertRuntimeIsLocal(persistentRoot, runtimeRoot, input.platform);
+    return Object.freeze({
+        layoutVersion: STORAGE_LAYOUT_VERSION,
+        environment,
+        workspaceId,
+        persistentRoot,
+        environmentRoot,
+        workspaceRoot,
+        agentItemsRoot: paths.join(workspaceRoot, "agent-items"),
+        daemonRoot: paths.join(workspaceRoot, "daemon"),
+        repoRoot: paths.join(workspaceRoot, "repos"),
+        suiteToolsRoot: paths.join(workspaceRoot, "suite-tools"),
+        migrationsRoot: paths.join(persistentRoot, "migrations"),
+        runtimeRoot,
+    });
+}
+export function agentStorageRoot(layout, agentId) {
+    const platform = layout.workspaceRoot.includes("\\") ? "win32" : "linux";
+    return pathsFor(platform).join(layout.agentItemsRoot, validateOpaqueId(agentId, "agent"));
+}
+const COMPARABLE_FIELDS = [
+    "layoutVersion", "environment", "workspaceId", "persistentRoot", "environmentRoot", "workspaceRoot",
+    "agentItemsRoot", "daemonRoot", "repoRoot", "suiteToolsRoot", "migrationsRoot", "runtimeRoot",
+];
+export function compareStorageLayout(current, expected) {
+    if (current === null || current.layoutVersion !== STORAGE_LAYOUT_VERSION)
+        return "unknown";
+    return COMPARABLE_FIELDS.every((field) => current[field] === expected[field])
+        ? "standard"
+        : "migration_required";
+}