@floomhq/floom 1.0.64 → 2.0.1

package/dist/sync-manifest.js

@@ -1,314 +0,0 @@
-import { constants, rmSync } from "node:fs";
-import { lstat, mkdir, open, rename, rm, stat, utimes } from "node:fs/promises";
-import { homedir } from "node:os";
-import { basename, dirname, join, relative, resolve, sep } from "node:path";
-import { CONFIG_DIR } from "./config.js";
-const MANIFEST_VERSION = 1;
-const LOCK_TIMEOUT_MS = 6 * 60_000;
-const LOCK_STALE_MS = 5 * 60_000;
-const LOCK_HEARTBEAT_MS = 30_000;
-const SLUG_RE = /^[A-Za-z0-9_-]{1,128}$/;
-const FD_PATH_ROOT = "/proc/self/fd";
-const SUPPORT_DIRS = new Set([
-    ".github",
-    "agents",
-    "assets",
-    "bin",
-    "canvas-fonts",
-    "checks",
-    "claude",
-    "codex",
-    "contrib",
-    "core",
-    "cursor",
-    "design",
-    "docs",
-    "evidence",
-    "examples",
-    "extension",
-    "helpers",
-    "hosts",
-    "kimi",
-    "lib",
-    "migrations",
-    "model-overlays",
-    "openclaw",
-    "opencode",
-    "reference",
-    "references",
-    "remotion-starter",
-    "scripts",
-    "sdk",
-    "schemas",
-    "src",
-    "specialists",
-    "supabase",
-    "templates",
-    "test",
-    "tests",
-    "themes",
-    "vendor",
-]);
-const ROOT_SUPPORT_FILES = new Set([
-    ".env.example",
-    "ACKNOWLEDGEMENTS.md",
-    "AGENTS.md",
-    "ARCHITECTURE.md",
-    "BROWSER.md",
-    "CHANGELOG.md",
-    "CLAUDE.md",
-    "CONTRIBUTING.md",
-    "DESIGN.md",
-    "ETHOS.md",
-    "LICENSE",
-    "LICENSE.md",
-    "LICENSE.txt",
-    "PLAN-snapshot-dropdown-interactive.md",
-    "README.md",
-    "REMOTION_PROTOCOL.md",
-    "SKILL.md.tmpl",
-    "TODOS.md",
-    "TODOS-format.md",
-    "USING_GBRAIN_WITH_GSTACK.md",
-    "VERSION",
-    ".gitlab-ci.yml",
-    "actionlint.yaml",
-    "bun.lock",
-    "checklist.md",
-    "conductor.json",
-    "design-checklist.md",
-    "dx-hall-of-fame.md",
-    "editing.md",
-    "forms.md",
-    "greptile-triage.md",
-    "instructions.md",
-    "nanobanana.py",
-    "package.json",
-    "plan.md",
-    "pptxgenjs.md",
-    "reference.md",
-    "requirements.txt",
-    "setup",
-    "skill.md",
-    "slop-scan.config.json",
-    "style_guidelines.md",
-    "theme-showcase.pdf",
-]);
-function emptyManifest() {
-    return { version: MANIFEST_VERSION, files: {} };
-}
-function expandHome(path) {
-    if (path === "~")
-        return homedir();
-    if (path.startsWith("~/"))
-        return join(homedir(), path.slice(2));
-    return path;
-}
-export function syncManifestPath() {
-    if (process.env.FLOOM_SYNC_MANIFEST_PATH)
-        return expandHome(process.env.FLOOM_SYNC_MANIFEST_PATH);
-    return join(CONFIG_DIR, "sync-manifest.json");
-}
-function syncManifestDir() {
-    return dirname(syncManifestPath());
-}
-function syncLockPath() {
-    return join(syncManifestDir(), "sync.lock");
-}
-function isEntryForKey(key, value) {
-    if (!value || typeof value !== "object")
-        return false;
-    const entry = value;
-    if (typeof entry.hash === "string" &&
-        typeof entry.slug === "string" &&
-        typeof entry.target === "string" &&
-        typeof entry.syncedAt === "string" &&
-        entry.target === key &&
-        SLUG_RE.test(entry.slug)) {
-        const segments = key.split("/");
-        const legacyFile = segments.at(-1) === `${entry.slug}.md`;
-        const slugIndex = segments.lastIndexOf(entry.slug);
-        const packagePath = slugIndex >= 0 ? segments.slice(slugIndex + 1) : [];
-        return legacyFile || isPackageFilePath(packagePath);
-    }
-    return false;
-}
-function isPackageFilePath(packagePath) {
-    if (packagePath.length === 1 && packagePath[0] === "SKILL.md")
-        return true;
-    if (packagePath.length === 1 && ROOT_SUPPORT_FILES.has(packagePath[0] ?? ""))
-        return true;
-    if (packagePath.length < 2)
-        return false;
-    const first = packagePath[0];
-    if (first === undefined || !SUPPORT_DIRS.has(first))
-        return false;
-    return packagePath.every((segment) => segment !== "." && segment !== ".." && segment.length > 0);
-}
-export async function readSyncManifest() {
-    try {
-        await ensureSyncManifestDir();
-        const handle = await open(syncManifestPath(), constants.O_RDONLY | constants.O_NOFOLLOW);
-        let body;
-        try {
-            body = await handle.readFile("utf8");
-        }
-        finally {
-            await handle.close();
-        }
-        const parsed = JSON.parse(body);
-        if (parsed.version !== MANIFEST_VERSION || !parsed.files || typeof parsed.files !== "object") {
-            return emptyManifest();
-        }
-        const manifest = emptyManifest();
-        for (const [key, value] of Object.entries(parsed.files)) {
-            if (isEntryForKey(key, value))
-                manifest.files[key] = value;
-        }
-        return manifest;
-    }
-    catch (err) {
-        if (err.code === "ENOENT")
-            return emptyManifest();
-        if (err instanceof SyntaxError)
-            return emptyManifest();
-        throw err;
-    }
-}
-export async function writeSyncManifest(manifest) {
-    await ensureSyncManifestDir();
-    const path = syncManifestPath();
-    const dirPath = dirname(path);
-    const targetName = basename(path);
-    const dir = await open(dirPath, constants.O_RDONLY | constants.O_DIRECTORY | constants.O_NOFOLLOW);
-    const tmpBase = `${targetName}.${process.pid}.${Date.now()}`;
-    const body = JSON.stringify(manifest, null, 2);
-    try {
-        for (let attempt = 0; attempt < 10; attempt += 1) {
-            const tmpName = attempt === 0 ? `${tmpBase}.tmp` : `${tmpBase}.${attempt}.tmp`;
-            const tmpPath = childPath(dir, dirPath, tmpName);
-            let handle = null;
-            try {
-                handle = await open(tmpPath, constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL | constants.O_NOFOLLOW, 0o600);
-                await handle.writeFile(body, "utf8");
-                await handle.close();
-                handle = null;
-                await rename(tmpPath, childPath(dir, dirPath, targetName));
-                return;
-            }
-            catch (err) {
-                await handle?.close().catch(() => { });
-                if (err.code === "EEXIST")
-                    continue;
-                throw err;
-            }
-        }
-    }
-    finally {
-        await dir.close();
-    }
-    const err = new Error("temporary sync manifest file already exists");
-    err.code = "EEXIST";
-    throw err;
-}
-function childPath(parent, fallbackParent, name) {
-    if (process.platform === "linux")
-        return `${FD_PATH_ROOT}/${parent.fd}/${name}`;
-    return join(resolve(fallbackParent), name);
-}
-export async function ensureSyncManifestDir() {
-    const dir = syncManifestDir();
-    await mkdir(dir, { recursive: true, mode: 0o700 });
-    const stat = await lstat(dir);
-    if (stat.isSymbolicLink()) {
-        const err = new Error("sync manifest directory is a symbolic link");
-        err.code = "ELOOP";
-        throw err;
-    }
-    if (!stat.isDirectory()) {
-        const err = new Error("sync manifest path is blocked by an existing local file");
-        err.code = "ENOTDIR";
-        throw err;
-    }
-}
-export async function withSyncLock(fn) {
-    await ensureSyncManifestDir();
-    const lockPath = syncLockPath();
-    const startedAt = Date.now();
-    for (;;) {
-        try {
-            await mkdir(lockPath, { mode: 0o700 });
-            break;
-        }
-        catch (err) {
-            if (err.code !== "EEXIST")
-                throw err;
-            try {
-                const lockStat = await stat(lockPath);
-                if (Date.now() - lockStat.mtimeMs > LOCK_STALE_MS) {
-                    await rm(lockPath, { recursive: true, force: true });
-                    continue;
-                }
-            }
-            catch (statErr) {
-                if (statErr.code === "ENOENT")
-                    continue;
-                throw statErr;
-            }
-            if (Date.now() - startedAt > LOCK_TIMEOUT_MS) {
-                throw new Error("Timed out waiting for Floom sync lock.");
-            }
-            await new Promise((resolveDelay) => setTimeout(resolveDelay, 50));
-        }
-    }
-    const signalHandlers = new Map();
-    const cleanupSync = () => {
-        try {
-            rmSync(lockPath, { recursive: true, force: true });
-        }
-        catch {
-            // Best-effort signal cleanup. The normal finally path reports real errors.
-        }
-    };
-    for (const signal of ["SIGINT", "SIGTERM"]) {
-        const handler = () => {
-            cleanupSync();
-            process.exit(signal === "SIGINT" ? 130 : 143);
-        };
-        signalHandlers.set(signal, handler);
-        process.once(signal, handler);
-    }
-    const heartbeat = setInterval(() => {
-        const now = new Date();
-        void utimes(lockPath, now, now).catch(() => { });
-    }, LOCK_HEARTBEAT_MS);
-    heartbeat.unref?.();
-    try {
-        return await fn();
-    }
-    finally {
-        clearInterval(heartbeat);
-        for (const [signal, handler] of signalHandlers) {
-            process.off(signal, handler);
-        }
-        await rm(lockPath, { recursive: true, force: true }).catch(() => { });
-    }
-}
-export function manifestKey(root, target) {
-    const relativeTarget = relative(resolve(root), resolve(target));
-    if (relativeTarget === ".." || relativeTarget.startsWith(`..${sep}`)) {
-        throw new Error("Invalid manifest target path.");
-    }
-    return relativeTarget.split(sep).join("/");
-}
-export function markSynced(manifest, key, slug, hash) {
-    manifest.files[key] = {
-        hash,
-        slug,
-        target: key,
-        syncedAt: new Date().toISOString(),
-    };
-}
-export function unmarkSynced(manifest, key) {
-    delete manifest.files[key];
-}