@floomhq/floom 1.0.39 → 1.0.41

package/dist/push-watch.js

@@ -156,30 +156,7 @@ export async function pushWatchOnce(opts) {
         const pushed = pushManifest.files[pushKey];
         if (pushed?.hash === hash) {
             if (!isUnchangedSyncedPackage(root, skillPackage, syncManifest)) {
-                if (opts.yolo) {
-                    try {
-                        await publishSkillPath({ file: packagePath, update: true, updateSlug: pushed.slug, quiet: true });
-                        updated += 1;
-                    }
-                    catch (err) {
-                        if (err instanceof Error && /Skill not found/i.test(err.message)) {
-                            const result = await publishSkillPath({ file: packagePath, visibility: "unlisted", quiet: true });
-                            published += 1;
-                            pushManifest.files[pushKey] = { hash, slug: result.data.slug, path: key, pushedAt: new Date().toISOString() };
-                            markPackageSynced(root, skillPackage, syncManifest, result.data.slug);
-                            await writeSyncManifest(syncManifest);
-                            continue;
-                        }
-                        skipped += 1;
-                        if (!opts.quiet) {
-                            process.stderr.write(`[floom] skipped ${packagePath}: ${err instanceof Error ? err.message : String(err)}\n`);
-                        }
-                        continue;
-                    }
-                }
-                else {
-                    adopted += 1;
-                }
+                adopted += 1;
                 markPackageSynced(root, skillPackage, syncManifest, pushed.slug);
                 await writeSyncManifest(syncManifest);
             }

package/dist/sync-manifest.js

@@ -1,10 +1,9 @@
 import { constants } from "node:fs";
 import { lstat, mkdir, open, rename, rm, stat } from "node:fs/promises";
-import { join, relative, resolve, sep } from "node:path";
+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 MANIFEST_PATH = join(CONFIG_DIR, "sync-manifest.json");
-const LOCK_PATH = join(CONFIG_DIR, "sync.lock");
 const LOCK_TIMEOUT_MS = 60_000;
 const LOCK_STALE_MS = 5 * 60_000;
 const SLUG_RE = /^[A-Za-z0-9_-]{1,128}$/;
@@ -55,6 +54,24 @@ const ROOT_SUPPORT_FILES = new Set([
 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;
@@ -88,7 +105,7 @@ function isPackageFilePath(packagePath) {
 export async function readSyncManifest() {
     try {
         await ensureSyncManifestDir();
-        const handle = await open(MANIFEST_PATH, constants.O_RDONLY | constants.O_NOFOLLOW);
+        const handle = await open(syncManifestPath(), constants.O_RDONLY | constants.O_NOFOLLOW);
         let body;
         try {
             body = await handle.readFile("utf8");
@@ -117,20 +134,23 @@ export async function readSyncManifest() {
 }
 export async function writeSyncManifest(manifest) {
     await ensureSyncManifestDir();
-    const dir = await open(CONFIG_DIR, constants.O_RDONLY | constants.O_DIRECTORY | constants.O_NOFOLLOW);
-    const tmpBase = `sync-manifest.json.${process.pid}.${Date.now()}`;
+    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, CONFIG_DIR, tmpName);
+            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, CONFIG_DIR, "sync-manifest.json"));
+                await rename(tmpPath, childPath(dir, dirPath, targetName));
                 return;
             }
             catch (err) {
@@ -154,8 +174,9 @@ function childPath(parent, fallbackParent, name) {
     return join(resolve(fallbackParent), name);
 }
 export async function ensureSyncManifestDir() {
-    await mkdir(CONFIG_DIR, { recursive: true, mode: 0o700 });
-    const stat = await lstat(CONFIG_DIR);
+    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";
@@ -169,19 +190,20 @@ export async function ensureSyncManifestDir() {
 }
 export async function withSyncLock(fn) {
     await ensureSyncManifestDir();
+    const lockPath = syncLockPath();
     const startedAt = Date.now();
     for (;;) {
         try {
-            await mkdir(LOCK_PATH, { mode: 0o700 });
+            await mkdir(lockPath, { mode: 0o700 });
             break;
         }
         catch (err) {
             if (err.code !== "EEXIST")
                 throw err;
             try {
-                const lockStat = await stat(LOCK_PATH);
+                const lockStat = await stat(lockPath);
                 if (Date.now() - lockStat.mtimeMs > LOCK_STALE_MS) {
-                    await rm(LOCK_PATH, { recursive: true, force: true });
+                    await rm(lockPath, { recursive: true, force: true });
                     continue;
                 }
             }
@@ -200,7 +222,7 @@ export async function withSyncLock(fn) {
         return await fn();
     }
     finally {
-        await rm(LOCK_PATH, { recursive: true, force: true }).catch(() => { });
+        await rm(lockPath, { recursive: true, force: true }).catch(() => { });
     }
 }
 export function manifestKey(root, target) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@floomhq/floom",
-  "version": "1.0.39",
+  "version": "1.0.41",
   "description": "Sync AI skills across agents and machines.",
   "license": "MIT",
   "type": "module",