@nowcrew/daemon 0.6.67 → 0.6.68

package/dist/storage-config.js

@@ -1,175 +0,0 @@
-import { readFile } from "node:fs/promises";
-import { posix, win32 } from "node:path";
-import { z } from "zod";
-import { atomicPrivateWrite } from "./atomic-private-write.js";
-import { resolveEnvTag, resolveNowworkHome, storageLayout, } from "./storage-layout.js";
-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 PROFILE = /^[a-z0-9][a-z0-9_-]{0,47}$/u;
-const PORTABLE_ABSOLUTE_PATH = z.string().min(1).max(32768).refine((value) => posix.isAbsolute(value) || win32.isAbsolute(value), "must be an absolute path");
-const ServerUrlSchema = z.string().url().max(2048).refine((value) => {
-    const url = new URL(value);
-    return (url.protocol === "http:" || url.protocol === "https:") && !url.username && !url.password;
-}, "serverUrl must be HTTP(S) without embedded credentials");
-const InstallationRecordSchema = z.object({
-    version: z.literal(1),
-    installationId: z.string().uuid(),
-    profile: z.string().regex(PROFILE),
-    serverUrl: ServerUrlSchema,
-    environment: z.string().regex(/^[a-z0-9][a-z0-9_-]{0,31}$/u),
-    workspaceId: z.string().uuid(),
-    storageId: z.string().min(1).max(128).regex(/^[A-Za-z0-9_-]+$/u),
-    nowworkHome: PORTABLE_ABSOLUTE_PATH,
-    runtimeRoot: PORTABLE_ABSOLUTE_PATH,
-    credentialRef: z.string().regex(/^profile:[a-z0-9][a-z0-9_-]{0,47}$/u),
-    storageMigrationId: z.string().uuid().optional(),
-    createdAt: z.string().datetime({ offset: true }),
-    updatedAt: z.string().datetime({ offset: true }),
-}).strict();
-const InstallationRegistrySchema = z.object({
-    version: z.literal(1),
-    installations: z.array(InstallationRecordSchema).max(256),
-}).strict();
-export function findInstallationForProfile(records, profile) {
-    if (!PROFILE.test(profile))
-        throw new Error("profile name is invalid");
-    const matches = records.filter((record) => record.profile === profile);
-    if (matches.length > 1)
-        throw new Error(`Multiple installations use profile '${profile}'`);
-    return matches[0] ?? null;
-}
-const pathsFor = (platform) => platform === "win32" ? win32 : posix;
-function absoluteBase(value, fallback, platform, name) {
-    const paths = pathsFor(platform);
-    const selected = value ?? fallback;
-    if (!paths.isAbsolute(selected) || selected.includes("\0") || selected.includes("\n") || selected.includes("\r")) {
-        throw new Error(`${name} must be an absolute single-line path`);
-    }
-    return paths.normalize(selected);
-}
-export function resolveLocalStorageRoots(input) {
-    const paths = pathsFor(input.platform);
-    const userHome = absoluteBase(input.userHome, input.userHome, input.platform, "user home");
-    if (input.platform === "win32") {
-        const local = absoluteBase(input.environment.LOCALAPPDATA, paths.join(userHome, "AppData", "Local"), input.platform, "LOCALAPPDATA");
-        const root = paths.join(local, "NowWork");
-        return Object.freeze({
-            configRoot: paths.join(root, "config"),
-            runtimeBase: paths.join(root, "runtime"),
-            cacheRoot: paths.join(root, "cache"),
-            stateRoot: paths.join(root, "state"),
-            backupsRoot: paths.join(root, "state", "backups"),
-            runtimePackagesRoot: paths.join(root, "cache", "runtime-packages"),
-        });
-    }
-    if (input.platform === "darwin") {
-        const applicationSupport = paths.join(userHome, "Library", "Application Support", "NowWork");
-        const cacheRoot = paths.join(userHome, "Library", "Caches", "NowWork");
-        return Object.freeze({
-            configRoot: paths.join(applicationSupport, "config"),
-            runtimeBase: paths.join(cacheRoot, "runtime"),
-            cacheRoot,
-            stateRoot: paths.join(applicationSupport, "state"),
-            backupsRoot: paths.join(applicationSupport, "state", "backups"),
-            runtimePackagesRoot: paths.join(cacheRoot, "runtime-packages"),
-        });
-    }
-    const configHome = absoluteBase(input.environment.XDG_CONFIG_HOME, paths.join(userHome, ".config"), input.platform, "XDG_CONFIG_HOME");
-    const cacheHome = absoluteBase(input.environment.XDG_CACHE_HOME, paths.join(userHome, ".cache"), input.platform, "XDG_CACHE_HOME");
-    const stateHome = absoluteBase(input.environment.XDG_STATE_HOME, paths.join(userHome, ".local", "state"), input.platform, "XDG_STATE_HOME");
-    const runtimeHome = absoluteBase(input.environment.XDG_RUNTIME_DIR, paths.join(stateHome, "nowwork", "runtime"), input.platform, "XDG_RUNTIME_DIR");
-    const stateRoot = paths.join(stateHome, "nowwork");
-    const cacheRoot = paths.join(cacheHome, "nowwork");
-    return Object.freeze({
-        configRoot: paths.join(configHome, "nowwork"),
-        runtimeBase: input.environment.XDG_RUNTIME_DIR === undefined ? runtimeHome : paths.join(runtimeHome, "nowwork"),
-        cacheRoot,
-        stateRoot,
-        backupsRoot: paths.join(stateRoot, "backups"),
-        runtimePackagesRoot: paths.join(cacheRoot, "runtime-packages"),
-    });
-}
-export function buildStorageConfig(input) {
-    if (!PROFILE.test(input.profile))
-        throw new Error("profile name is invalid");
-    if (!UUID.test(input.workspaceId))
-        throw new Error("workspace id must be a UUID");
-    const paths = pathsFor(input.platform);
-    const local = resolveLocalStorageRoots(input);
-    const home = resolveNowworkHome({
-        ...(input.nowworkHome === undefined ? {} : { explicit: input.nowworkHome }),
-        ...(input.environment.NOWWORK_HOME === undefined ? {} : { environment: input.environment.NOWWORK_HOME }),
-        userHome: input.userHome,
-        platform: input.platform,
-    });
-    const credentialRef = `profile:${input.profile}`;
-    if (home.mode === "legacy") {
-        return Object.freeze({
-            mode: "legacy",
-            profile: input.profile,
-            workspaceId: input.workspaceId.toLowerCase(),
-            credentialRef,
-            daemonHome: input.legacyDaemonHome ?? paths.join(input.userHome, ".crew", "daemon"),
-            agentsRoot: input.legacyAgentsRoot ?? paths.join(input.userHome, ".crew", "agents"),
-            layout: null,
-            local,
-            diagnostics: Object.freeze(["legacy_storage_detected"]),
-        });
-    }
-    const environment = resolveEnvTag({
-        ...(input.envTag === undefined ? {} : { explicit: input.envTag }),
-        ...(input.environment.NOWWORK_ENV_TAG === undefined ? {} : { environment: input.environment.NOWWORK_ENV_TAG }),
-    }).environment;
-    const layout = storageLayout({
-        nowworkHome: home.root,
-        environment,
-        workspaceId: input.workspaceId,
-        runtimeBase: local.runtimeBase,
-        platform: input.platform,
-    });
-    return Object.freeze({
-        mode: "standard",
-        profile: input.profile,
-        workspaceId: input.workspaceId.toLowerCase(),
-        credentialRef,
-        daemonHome: local.configRoot,
-        agentsRoot: layout.agentItemsRoot,
-        layout,
-        local,
-        diagnostics: Object.freeze([]),
-    });
-}
-export function installationsPath(configRoot) {
-    const paths = win32.isAbsolute(configRoot) && !posix.isAbsolute(configRoot) ? win32 : posix;
-    return paths.join(configRoot, "installations.json");
-}
-export async function readInstallations(input) {
-    const path = installationsPath(input.configRoot);
-    try {
-        const parsed = InstallationRegistrySchema.parse(JSON.parse(await readFile(path, "utf8")));
-        return Object.freeze(parsed.installations.map((record) => Object.freeze(record)));
-    }
-    catch (error) {
-        if (error.code === "ENOENT")
-            return Object.freeze([]);
-        throw new Error(`Invalid installation registry: ${path}`, { cause: error });
-    }
-}
-export async function writeInstallations(records, input) {
-    let parsed;
-    try {
-        parsed = InstallationRegistrySchema.parse({ version: 1, installations: records });
-        const installationIds = new Set();
-        const profiles = new Set();
-        for (const record of parsed.installations) {
-            if (installationIds.has(record.installationId) || profiles.has(record.profile)) {
-                throw new Error("duplicate installation identity");
-            }
-            installationIds.add(record.installationId);
-            profiles.add(record.profile);
-        }
-    }
-    catch (error) {
-        throw new Error("Invalid installation metadata", { cause: error });
-    }
-    await atomicPrivateWrite(installationsPath(input.configRoot), `${JSON.stringify(parsed, null, 2)}\n`);
-}

package/dist/storage-control.js

@@ -1,193 +0,0 @@
-import { z } from "zod";
-export const STORAGE_MIGRATION_CAPABILITY = "storage_migration_v1";
-export const STORAGE_MIGRATION_STATUS_CAPABILITY = "storage_migration_status_v1";
-const IdentitySchema = z.object({
-    migrationId: z.string().uuid(),
-    environment: z.string().regex(/^[a-z0-9][a-z0-9_-]{0,31}$/u),
-    workspaceId: z.string().uuid(),
-});
-const DoctorRequestSchema = IdentitySchema.extend({ type: z.literal("daemon:storage-doctor") }).strict();
-const MigrateRequestSchema = IdentitySchema.extend({
-    type: z.literal("daemon:storage-migrate"),
-    manifestDigest: z.string().regex(/^[0-9a-f]{64}$/u),
-}).strict();
-const StatusSchema = z.enum([
-    "preflight_running", "preflight_passed", "backing_up", "initial_sync", "quiescing", "final_sync", "verified",
-    "service_switched", "hello_confirmed", "completed", "failed", "rollback_pending", "rolled_back",
-    "rollback_failed",
-]);
-const TOKEN = /(?:\bsk_(?:machine|user|agent)_[A-Za-z0-9_-]{4,}\b|\bbearer\s+[^\s]+|(?:password|secret|token)\s*[:=]\s*[^\s]+)/giu;
-const safeError = (error) => (error instanceof Error ? error.message : String(error))
-    .replaceAll(TOKEN, "<redacted>").slice(0, 500) || "storage migration failed";
-const stableErrorCode = (candidate, fallback) => typeof candidate === "string" && /^[a-z0-9._-]{1,128}$/u.test(candidate) ? candidate : fallback;
-export function createStorageControlController(input) {
-    const environment = z.string().regex(/^[a-z0-9][a-z0-9_-]{0,31}$/u).parse(input.environment);
-    const workspaceId = z.string().uuid().parse(input.workspaceId);
-    const profile = z.string().regex(/^[a-z0-9][a-z0-9_-]{0,47}$/u).parse(input.profile);
-    const sourceStorageFingerprint = z.string().regex(/^sha256:[0-9a-f]{64}$/u).parse(input.sourceStorageFingerprint);
-    const targetStorageFingerprint = z.string().regex(/^sha256:[0-9a-f]{64}$/u).parse(input.targetStorageFingerprint);
-    const preflights = new Map();
-    const preflightRuns = new Map();
-    const appliedMigrationIds = new Set();
-    let runningMigrationId = null;
-    const preflightTimeoutMs = z.number().int().positive().max(24 * 60 * 60 * 1000)
-        .parse(input.preflightTimeoutMs ?? 30 * 60 * 1000);
-    const frame = (identity, status, extra = {}) => ({
-        type: "daemon:storage-migration-status",
-        migrationId: identity.migrationId,
-        status,
-        environment,
-        workspaceId,
-        profile,
-        ...extra,
-    });
-    const failure = (identity, errorCode, error, reopenAdmission = false, extra = {}) => {
-        input.sendStatus(frame(identity, "failed", {
-            errorCode,
-            ...extra,
-            ...(error === undefined ? {} : { errorMessage: safeError(error) }),
-            ...(reopenAdmission || error?.reopenAdmission === true
-                ? { reopenAdmission: true }
-                : {}),
-        }));
-    };
-    const matchesIdentity = (identity) => identity.environment === environment && identity.workspaceId === workspaceId;
-    const preflightKey = (identity) => `${identity.migrationId}\0${identity.environment}\0${identity.workspaceId}`;
-    const runPreflight = (identity, failureFallback = "doctor_failed") => {
-        const key = preflightKey(identity);
-        const existing = preflightRuns.get(key);
-        if (existing !== undefined)
-            return existing;
-        const controller = new AbortController();
-        let scannedEntries = 0;
-        let timedOut = false;
-        input.sendStatus(frame(identity, "preflight_running", {
-            progress: { state: "running", scannedEntries: 0 },
-        }));
-        const doctorPromise = Promise.resolve().then(() => input.runDoctor(identity.migrationId, {
-            signal: controller.signal,
-            onProgress: (progress) => {
-                if (timedOut)
-                    return;
-                scannedEntries = progress.scannedEntries;
-                input.sendStatus(frame(identity, "preflight_running", {
-                    progress: { state: "running", scannedEntries },
-                }));
-            },
-        }));
-        let timeoutHandle;
-        const timeout = new Promise((_, reject) => {
-            timeoutHandle = setTimeout(() => {
-                timedOut = true;
-                controller.abort();
-                reject(Object.assign(new Error("storage doctor preflight timed out"), {
-                    code: "preflight_stale",
-                    scannedEntries,
-                }));
-            }, preflightTimeoutMs);
-            timeoutHandle.unref?.();
-        });
-        void doctorPromise.catch(() => undefined);
-        let outcome;
-        outcome = Promise.race([doctorPromise, timeout]).then((doctor) => {
-            if (doctor.manifest.migrationId !== identity.migrationId
-                || doctor.environment !== environment || doctor.workspaceId !== workspaceId
-                || doctor.profile !== profile) {
-                failure(identity, "storage_identity_mismatch", undefined, true);
-                return null;
-            }
-            if (!doctor.applyAllowed) {
-                failure(identity, doctor.blockers[0]?.code ?? "doctor_blocked", undefined, true);
-                return null;
-            }
-            preflights.set(identity.migrationId, doctor);
-            input.sendStatus(frame(identity, "preflight_passed", {
-                sourceStorageFingerprint,
-                targetStorageFingerprint,
-                manifestDigest: doctor.manifestDigest,
-            }));
-            return doctor;
-        }).catch((error) => {
-            const code = error.code;
-            if (code === "preflight_stale") {
-                failure(identity, "preflight_stale", undefined, true, {
-                    retryable: true,
-                    progress: { state: "stale", scannedEntries: Number(error.scannedEntries) || scannedEntries },
-                });
-            }
-            else if (code === "preflight_aborted") {
-                failure(identity, "preflight_aborted", error, true, {
-                    retryable: true,
-                    progress: { state: "stale", scannedEntries },
-                });
-            }
-            else {
-                failure(identity, stableErrorCode(code, failureFallback), error, true);
-            }
-            return null;
-        }).finally(() => {
-            if (timeoutHandle !== undefined)
-                clearTimeout(timeoutHandle);
-            if (preflightRuns.get(key) === outcome)
-                preflightRuns.delete(key);
-        });
-        preflightRuns.set(key, outcome);
-        return outcome;
-    };
-    const handle = async (raw) => {
-        const type = typeof raw === "object" && raw !== null && "type" in raw ? raw.type : null;
-        if (type !== "daemon:storage-doctor" && type !== "daemon:storage-migrate")
-            return false;
-        const schema = type === "daemon:storage-doctor" ? DoctorRequestSchema : MigrateRequestSchema;
-        const parsed = schema.safeParse(raw);
-        if (!parsed.success)
-            return true;
-        const identity = parsed.data;
-        if (!matchesIdentity(identity)) {
-            failure(identity, "storage_identity_mismatch", undefined, true);
-            return true;
-        }
-        if (type === "daemon:storage-doctor") {
-            await runPreflight(identity);
-            return true;
-        }
-        if (runningMigrationId !== null) {
-            if (runningMigrationId !== identity.migrationId)
-                failure(identity, "migration_active");
-            return true;
-        }
-        const migrate = MigrateRequestSchema.parse(identity);
-        if (appliedMigrationIds.has(identity.migrationId))
-            return true;
-        let doctor = preflights.get(identity.migrationId);
-        if (doctor === undefined) {
-            const rebuilt = await runPreflight(identity, "preflight_rebuild_failed");
-            if (rebuilt === null)
-                return true;
-            doctor = rebuilt;
-        }
-        if (!doctor.applyAllowed || doctor.manifestDigest !== migrate.manifestDigest
-            || doctor.manifest.migrationId !== identity.migrationId
-            || doctor.environment !== environment || doctor.workspaceId !== workspaceId || doctor.profile !== profile) {
-            failure(identity, "preflight_digest_mismatch", undefined, true);
-            return true;
-        }
-        preflights.delete(identity.migrationId);
-        runningMigrationId = identity.migrationId;
-        try {
-            await input.runMigration(doctor, (status) => {
-                if (StatusSchema.safeParse(status).success)
-                    input.sendStatus(frame(identity, status));
-            });
-            appliedMigrationIds.add(identity.migrationId);
-        }
-        catch (error) {
-            failure(identity, stableErrorCode(error.code, "storage_migration_failed"), error);
-        }
-        finally {
-            runningMigrationId = null;
-        }
-        return true;
-    };
-    return Object.freeze({ handle });
-}