@floomhq/floom 1.0.52 → 1.0.54

package/dist/cli.js

@@ -21,6 +21,7 @@ import { auditSkills } from "./audit.js";
 import { share } from "./share.js";
 import { feedback } from "./feedback.js";
 import { status } from "./status.js";
+import { launchGate } from "./launch.js";
 import { libraryAddSkill, libraryCreate, libraryList, libraryRemoveSkill, librarySubscribe, libraryUnsubscribe, moveSkill, } from "./library.js";
 import { c, symbols } from "./ui.js";
 import { printError, FloomError } from "./errors.js";
@@ -129,6 +130,8 @@ function commandUsage() {
                        ${c.dim(`Flags: install|status|logs|run, --target ${TARGET_HINT}|all`)}
      ${c.cyan("audit skills")}       Read-only skill quality and duplicate report
                        ${c.dim("Flags: --json, --fix-plan")}
+     ${c.cyan("launch gate")}        Check pinned release identity for launch evidence
+                       ${c.dim("Flags: --json")}
 
  ${c.bold("Examples")}
    ${c.cyan("npx -y @floomhq/floom add")} ${c.dim("https://floom.dev/s/ffas93ud --setup")}
@@ -337,6 +340,9 @@ function subcommandUsage(cmd) {
         case "feedback":
             feedbackUsage();
             return true;
+        case "launch":
+            commandUsage();
+            return true;
         case "library":
         case "lib":
             libraryUsage();
@@ -1209,6 +1215,16 @@ async function main() {
                 });
                 return;
             }
+            case "launch": {
+                const sub = rest[0];
+                if (sub !== "gate")
+                    throw new FloomError("Unknown launch command.", `Try \`${CLI_COMMAND} launch gate --json\`.`);
+                const args = rest.slice(1);
+                const json = args.includes("--json");
+                rejectArgs(args.filter((arg) => arg !== "--json"), `Try \`${CLI_COMMAND} launch gate --json\`.`);
+                await launchGate({ json });
+                return;
+            }
             case "status":
                 await status(parseStatusFlags(rest));
                 return;

package/dist/launch.js

@@ -0,0 +1,82 @@
+import { readFile } from "node:fs/promises";
+import { CONFIG_DIR, readConfig, resolveApiUrl } from "./config.js";
+import { floomFetch } from "./lib/api.js";
+import { CLI_VERSION } from "./version.js";
+import { c, symbols } from "./ui.js";
+import { FloomError } from "./errors.js";
+import { join } from "node:path";
+async function readDaemonStatus() {
+    try {
+        return JSON.parse(await readFile(join(CONFIG_DIR, "daemon-status.json"), "utf8"));
+    }
+    catch (err) {
+        if (err.code === "ENOENT")
+            return null;
+        throw err;
+    }
+}
+async function getJson(url, action, token) {
+    try {
+        const res = await floomFetch(url, action, {
+            ...(token ? { token } : {}),
+            timeoutMs: 8_000,
+            rateLimitRetries: 0,
+        });
+        return (await res.json());
+    }
+    catch {
+        return null;
+    }
+}
+export async function launchGate(opts) {
+    const cfg = await readConfig();
+    const apiUrl = resolveApiUrl(cfg ?? undefined);
+    const [health, cliVersion, daemon] = await Promise.all([
+        getJson(`${apiUrl}/api/v1/health`, "check launch health", cfg?.accessToken),
+        getJson(`${apiUrl}/api/v1/cli-version`, "check CLI version", cfg?.accessToken),
+        readDaemonStatus(),
+    ]);
+    const targetResults = daemon?.last_run ?? {};
+    const targets = daemon?.targets ?? [];
+    const daemonTargetsOk = targets.length > 0 && targets.every((target) => targetResults[target]?.ok === true);
+    const releaseAligned = health?.version === CLI_VERSION && cliVersion?.latest === CLI_VERSION;
+    const payload = {
+        ok: Boolean(health?.ok && releaseAligned && daemon?.running && daemon?.version === CLI_VERSION),
+        release: {
+            cli: CLI_VERSION,
+            web: health?.version ?? null,
+            cli_latest: cliVersion?.latest ?? null,
+            cli_min: cliVersion?.min ?? null,
+            release_aligned: releaseAligned,
+        },
+        health: health ?? null,
+        daemon: daemon ? {
+            running: daemon.running === true,
+            version: daemon.version ?? null,
+            hostname: daemon.hostname ?? null,
+            targets,
+            all_targets_ok: daemonTargetsOk,
+            last_completed_at: daemon.last_completed_at ?? null,
+            last_run: targetResults,
+        } : null,
+        escalations: [
+            ...(releaseAligned ? [] : ["CLI, web health, and server latest versions are not aligned."]),
+            ...(daemon?.running && daemon.version === CLI_VERSION ? [] : ["Daemon is not running on the pinned CLI version."]),
+            ...(targets.length === 0 || daemonTargetsOk ? [] : ["Latest daemon cycle has not yet passed for every configured target."]),
+        ],
+    };
+    if (opts.json) {
+        process.stdout.write(`${JSON.stringify(payload, null, 2)}\n`);
+        return;
+    }
+    process.stdout.write(`\n${symbols.dot}  ${c.bold("Floom launch gate")}\n\n`);
+    process.stdout.write(`   ${c.dim("CLI:")} ${payload.release.cli}\n`);
+    process.stdout.write(`   ${c.dim("Web:")} ${payload.release.web ?? "unknown"}\n`);
+    process.stdout.write(`   ${c.dim("Daemon:")} ${payload.daemon?.running ? `running (${payload.daemon.version})` : "not running"}\n`);
+    if (payload.escalations.length > 0) {
+        for (const escalation of payload.escalations)
+            process.stdout.write(`   ${symbols.bullet} ${escalation}\n`);
+        throw new FloomError("Launch gate did not pass.", "Run with --json for machine-readable details.");
+    }
+    process.stdout.write(`\n${symbols.ok}  Launch gate passed for the pinned local release identity.\n\n`);
+}

package/dist/sync.js

@@ -1,5 +1,5 @@
 import { constants } from "node:fs";
-import { lstat, mkdir, open } from "node:fs/promises";
+import { lstat, mkdir, open, rm, rmdir } from "node:fs/promises";
 import { createHash } from "node:crypto";
 import { basename, dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
 import ora from "ora";
@@ -224,6 +224,40 @@ async function overwriteTrackedFile(root, target, body, expectedHash) {
         await parent.close();
     }
 }
+async function deleteSyncedFile(root, target, expectedHash) {
+    const state = await localState(target);
+    if (state.kind === "missing")
+        return;
+    if (state.kind === "conflict")
+        throw conflictError(state.reason, "EEXIST");
+    if (state.hash !== expectedHash)
+        throw conflictError("local file changed since the last Floom sync", "EEXIST");
+    await rm(target);
+    await pruneEmptyParents(root, dirname(target));
+}
+async function pruneEmptyParents(root, startDir) {
+    const resolvedRoot = resolve(root);
+    let current = resolve(startDir);
+    for (;;) {
+        const relativeCurrent = relative(resolvedRoot, current);
+        if (!relativeCurrent || relativeCurrent === ".." || relativeCurrent.startsWith(`..${sep}`) || isAbsolute(relativeCurrent))
+            return;
+        try {
+            await rmdir(current);
+        }
+        catch (err) {
+            const code = err.code;
+            if (code === "ENOENT") {
+                current = dirname(current);
+                continue;
+            }
+            if (code === "ENOTEMPTY" || code === "EEXIST" || code === "ENOTDIR")
+                return;
+            throw err;
+        }
+        current = dirname(current);
+    }
+}
 async function ensureSafeParentDirectory(root, target) {
     const resolvedRoot = resolve(root);
     const resolvedParent = resolve(dirname(target));
@@ -446,6 +480,26 @@ export async function sync(opts = {}) {
                             noteConflict(target, "local file changed since the last Floom sync");
                             continue;
                         }
+                        try {
+                            await deleteSyncedFile(root, target, entry.hash);
+                        }
+                        catch (err) {
+                            const code = err.code;
+                            if (code === "ENOENT") {
+                                unmarkSynced(manifest, key);
+                                manifestChanged = true;
+                                continue;
+                            }
+                            if (code === "ELOOP") {
+                                noteManifestConflict(key, "path contains a symbolic link");
+                                continue;
+                            }
+                            if (code === "ENOTDIR" || code === "EISDIR" || code === "EEXIST") {
+                                noteManifestConflict(key, err instanceof Error ? err.message : "local file changed since the last Floom sync");
+                                continue;
+                            }
+                            throw err;
+                        }
                         unmarkSynced(manifest, key);
                         manifestChanged = true;
                     }

package/package.json

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