@floomhq/floom 1.0.0

package/dist/doctor.js

@@ -0,0 +1,270 @@
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { stat, readFile, access, readdir, constants } from "node:fs/promises";
+import { getApiUrl, readConfig, CONFIG_PATH } from "./config.js";
+import { c, symbols } from "./ui.js";
+const CLI_VERSION = "1.0.0";
+function statusBadge(s) {
+    if (s === "ok")
+        return c.green(symbols.ok);
+    if (s === "warn")
+        return c.yellow("!");
+    return c.red(symbols.fail);
+}
+async function checkAuth() {
+    const cfg = await readConfig();
+    if (!cfg) {
+        return {
+            name: "Auth",
+            status: "ok",
+            detail: "Receiver mode ready. Sign in only when publishing or listing your own skills.",
+        };
+    }
+    const apiUrl = cfg.apiUrl ?? getApiUrl();
+    try {
+        const res = await fetch(`${apiUrl}/api/me`, {
+            headers: { authorization: `Bearer ${cfg.accessToken}` },
+        });
+        if (res.status === 401) {
+            return {
+                name: "Auth",
+                status: "fail",
+                detail: "Token rejected (401).",
+                hint: "Run `floom logout && floom login` to refresh.",
+            };
+        }
+        if (!res.ok) {
+            return {
+                name: "Auth",
+                status: "warn",
+                detail: `API returned ${res.status}.`,
+                hint: "Service may be degraded; try again shortly.",
+            };
+        }
+        const data = (await res.json());
+        return {
+            name: "Auth",
+            status: "ok",
+            detail: data.email ? `Signed in as ${data.email}` : "Signed in",
+        };
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        return {
+            name: "Auth",
+            status: "fail",
+            detail: `Cannot reach ${apiUrl}: ${msg}`,
+            hint: "Check your network. Try `curl " + apiUrl + "/api/me`.",
+        };
+    }
+}
+async function checkMcp() {
+    const candidates = [
+        { name: "Claude Code", path: join(homedir(), ".claude.json") },
+        { name: "Claude Code (settings)", path: join(homedir(), ".claude", "settings.json") },
+        { name: "Codex", path: join(homedir(), ".codex", "config.toml") },
+        { name: "Gemini", path: join(homedir(), ".gemini", "settings.json") },
+    ];
+    const found = [];
+    for (const cand of candidates) {
+        try {
+            const buf = await readFile(cand.path, "utf8");
+            // Cheap match: any reference to a Floom MCP server. The actual MCP
+            // package name is @floomhq/floom-mcp-sync. Detect by package name OR
+            // by "floom" + "mcp_servers"/"mcpServers" co-occurrence.
+            const hasFloom = buf.includes("@floomhq/floom-mcp-sync") ||
+                (buf.includes("\"floom\"") && (buf.includes("mcpServers") || buf.includes("mcp_servers"))) ||
+                (buf.includes("[mcp_servers.floom]"));
+            if (hasFloom)
+                found.push({ name: cand.name, configPath: cand.path, hasFloom });
+        }
+        catch {
+            // file missing — fine
+        }
+    }
+    if (found.length === 0) {
+        return {
+            name: "MCP",
+            status: "ok",
+            detail: "Optional MCP not registered. `floom add` still writes local skill files.",
+        };
+    }
+    return {
+        name: "MCP",
+        status: "ok",
+        detail: `Registered with: ${found.map((f) => f.name).join(", ")}`,
+    };
+}
+function targetSkillsDir() {
+    return process.env.CLAUDE_SKILLS_DIR ?? join(homedir(), ".claude", "skills");
+}
+async function checkTargetDir() {
+    const dir = targetSkillsDir();
+    try {
+        const s = await stat(dir);
+        if (!s.isDirectory()) {
+            return {
+                name: "Target dir",
+                status: "fail",
+                detail: `${dir} exists but is not a directory.`,
+            };
+        }
+        try {
+            await access(dir, constants.W_OK);
+            return { name: "Target dir", status: "ok", detail: `${dir} (writable)` };
+        }
+        catch {
+            return {
+                name: "Target dir",
+                status: "fail",
+                detail: `${dir} is not writable.`,
+                hint: `Try: chmod u+w ${dir}`,
+            };
+        }
+    }
+    catch (err) {
+        if (err.code === "ENOENT") {
+            return {
+                name: "Target dir",
+                status: "warn",
+                detail: `${dir} does not exist yet.`,
+                hint: "It will be created on first `floom add`.",
+            };
+        }
+        throw err;
+    }
+}
+async function checkLastSync() {
+    const dir = targetSkillsDir();
+    try {
+        const entries = await readdir(dir);
+        const skills = entries.filter((e) => e.endsWith(".md") || !e.startsWith("."));
+        if (skills.length === 0) {
+            return {
+                name: "Last sync",
+                status: "warn",
+                detail: "No synced skills found yet.",
+                hint: "Run `floom add <link>` to install your first skill.",
+            };
+        }
+        // Find most recently modified entry
+        let newest = { name: "", mtime: 0 };
+        for (const name of skills) {
+            try {
+                const s = await stat(join(dir, name));
+                if (s.mtimeMs > newest.mtime)
+                    newest = { name, mtime: s.mtimeMs };
+            }
+            catch {
+                // skip
+            }
+        }
+        if (newest.mtime === 0) {
+            return {
+                name: "Last sync",
+                status: "warn",
+                detail: `${skills.length} entries, no readable mtime.`,
+            };
+        }
+        const ageSec = Math.round((Date.now() - newest.mtime) / 1000);
+        const human = ageSec < 60
+            ? `${ageSec}s ago`
+            : ageSec < 3600
+                ? `${Math.round(ageSec / 60)}m ago`
+                : ageSec < 86400
+                    ? `${Math.round(ageSec / 3600)}h ago`
+                    : `${Math.round(ageSec / 86400)}d ago`;
+        return {
+            name: "Last sync",
+            status: "ok",
+            detail: `${newest.name} — ${human} (${skills.length} total)`,
+        };
+    }
+    catch (err) {
+        if (err.code === "ENOENT") {
+            return {
+                name: "Last sync",
+                status: "warn",
+                detail: "Skills dir not created yet.",
+            };
+        }
+        return {
+            name: "Last sync",
+            status: "warn",
+            detail: `Cannot read skills dir: ${err.message}`,
+        };
+    }
+}
+async function checkVersion() {
+    const apiUrl = (await readConfig())?.apiUrl ?? getApiUrl();
+    try {
+        const res = await fetch(`${apiUrl}/api/v1/cli-version`, {
+            headers: { accept: "application/json" },
+        });
+        if (!res.ok) {
+            // Endpoint optional — treat as info-only, not a failure
+            return {
+                name: "Version",
+                status: "ok",
+                detail: `CLI v${CLI_VERSION} (server check skipped)`,
+            };
+        }
+        const data = (await res.json());
+        if (data.min && CLI_VERSION < data.min) {
+            return {
+                name: "Version",
+                status: "fail",
+                detail: `CLI v${CLI_VERSION} below required v${data.min}.`,
+                hint: "Run `npm i -g @floomhq/floom` to upgrade.",
+            };
+        }
+        if (data.latest && CLI_VERSION !== data.latest) {
+            return {
+                name: "Version",
+                status: "warn",
+                detail: `CLI v${CLI_VERSION}, latest is v${data.latest}.`,
+                hint: "Run `npm i -g @floomhq/floom` to upgrade.",
+            };
+        }
+        return { name: "Version", status: "ok", detail: `CLI v${CLI_VERSION} (current)` };
+    }
+    catch {
+        return {
+            name: "Version",
+            status: "ok",
+            detail: `CLI v${CLI_VERSION} (offline)`,
+        };
+    }
+}
+export async function doctor() {
+    process.stdout.write(`\n${c.bold("floom doctor")} ${c.dim(`(v${CLI_VERSION})`)}\n\n`);
+    const checks = await Promise.all([
+        checkAuth(),
+        checkMcp(),
+        checkTargetDir(),
+        checkLastSync(),
+        checkVersion(),
+    ]);
+    // Compute column widths for clean table output.
+    const nameW = Math.max(...checks.map((c) => c.name.length), 6);
+    for (const check of checks) {
+        const padded = check.name.padEnd(nameW);
+        process.stdout.write(`  ${statusBadge(check.status)} ${c.bold(padded)}  ${check.detail}\n`);
+        if (check.hint && check.status !== "ok") {
+            process.stdout.write(`     ${c.dim("→ " + check.hint)}\n`);
+        }
+    }
+    const anyFail = checks.some((c) => c.status === "fail");
+    const anyWarn = checks.some((c) => c.status === "warn");
+    process.stdout.write("\n");
+    if (anyFail) {
+        process.stdout.write(`  ${c.red("✗ Some checks failed.")} See hints above.\n\n`);
+        process.exit(1);
+    }
+    if (anyWarn) {
+        process.stdout.write(`  ${c.yellow("! All critical checks passed, with warnings.")}\n\n`);
+        process.exit(0);
+    }
+    process.stdout.write(`  ${c.green("✓ All checks passed.")} Floom is healthy.\n\n`);
+    process.stdout.write(`  ${c.dim("Config: " + CONFIG_PATH)}\n\n`);
+}

package/dist/errors.js

@@ -0,0 +1,51 @@
+import { c, symbols } from "./ui.js";
+/**
+ * FloomError is a friendly, user-facing error. Throw this instead of raw Error
+ * when you want a clean message (no stack trace, no "Error:" prefix).
+ */
+export class FloomError extends Error {
+    hint;
+    constructor(message, hint) {
+        super(message);
+        this.name = "FloomError";
+        if (hint)
+            this.hint = hint;
+    }
+}
+export function friendlyHttp(status, action) {
+    if (status === 401) {
+        return new FloomError("Your token expired.", "Run `floom login` to refresh.");
+    }
+    if (status === 403) {
+        return new FloomError(`You don't have permission to ${action}.`);
+    }
+    if (status === 404) {
+        return new FloomError("Skill not found.", "Run `floom publish` without `--update` to create a new one.");
+    }
+    if (status === 413) {
+        return new FloomError("That file is too large to publish.");
+    }
+    if (status >= 500) {
+        return new FloomError("Floom is having trouble right now.", "Try again in a moment.");
+    }
+    return new FloomError(`Request failed (HTTP ${status}) while trying to ${action}.`);
+}
+export function friendlyNetwork(err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    if (/ENOTFOUND|EAI_AGAIN|ECONNREFUSED|ECONNRESET|ETIMEDOUT|fetch failed/i.test(msg)) {
+        return new FloomError("Couldn't reach floom (offline?).", "Try again in a moment.");
+    }
+    return new FloomError(msg);
+}
+export function printError(err) {
+    if (err instanceof FloomError) {
+        process.stderr.write(`\n${symbols.fail}  ${err.message}\n`);
+        if (err.hint)
+            process.stderr.write(`   ${c.dim(err.hint)}\n\n`);
+        else
+            process.stderr.write("\n");
+        return;
+    }
+    const msg = err instanceof Error ? err.message : String(err);
+    process.stderr.write(`\n${symbols.fail}  ${msg}\n\n`);
+}

package/dist/info.js

@@ -0,0 +1,66 @@
+import ora from "ora";
+import { getApiUrl, readConfig } from "./config.js";
+import { getJson } from "./lib/api.js";
+import { c, symbols } from "./ui.js";
+import { FloomError } from "./errors.js";
+function slugFromInput(input) {
+    const trimmed = input.trim();
+    try {
+        const url = new URL(trimmed);
+        const last = url.pathname.split("/").filter(Boolean).at(-1) ?? "";
+        return last.replace(/\.(md|json)$/i, "");
+    }
+    catch {
+        return trimmed.replace(/\.(md|json)$/i, "");
+    }
+}
+export async function info(opts) {
+    const slug = slugFromInput(opts.slug);
+    if (!slug)
+        throw new FloomError("Missing skill slug.", "Try: `floom info <slug>`");
+    const cfg = await readConfig();
+    const apiUrl = cfg?.apiUrl ?? getApiUrl();
+    const spinner = opts.json ? null : ora({ text: c.dim(`Loading ${slug}...`), color: "yellow" }).start();
+    let detail;
+    try {
+        detail = await getJson(`${apiUrl}/api/v1/skills/${encodeURIComponent(slug)}`, "load skill metadata", cfg?.accessToken);
+    }
+    finally {
+        spinner?.stop();
+    }
+    if (opts.json) {
+        // Strip body_md from JSON output to keep it summary-shaped.
+        const { body_md: _body, ...summary } = detail;
+        process.stdout.write(`${JSON.stringify(summary, null, 2)}\n`);
+        return;
+    }
+    const title = detail.title ?? c.dim("(untitled)");
+    process.stdout.write(`\n${symbols.dot}  ${c.bold(title)}\n\n`);
+    process.stdout.write(`   ${c.dim("Slug:       ")}${detail.slug}\n`);
+    if (detail.description) {
+        process.stdout.write(`   ${c.dim("About:      ")}${detail.description}\n`);
+    }
+    process.stdout.write(`   ${c.dim("Visibility: ")}${detail.visibility}\n`);
+    process.stdout.write(`   ${c.dim("Type:       ")}${detail.asset_type ?? "skill"}\n`);
+    if (detail.version) {
+        process.stdout.write(`   ${c.dim("Version:    ")}${detail.version}\n`);
+    }
+    if (detail.installs_as) {
+        process.stdout.write(`   ${c.dim("Installs:   ")}${detail.installs_as}\n`);
+    }
+    if (detail.original_filename) {
+        process.stdout.write(`   ${c.dim("File:       ")}${detail.original_filename}\n`);
+    }
+    if (detail.owner_email) {
+        process.stdout.write(`   ${c.dim("Owner:      ")}${detail.owner_email}\n`);
+    }
+    if (typeof detail.save_count === "number") {
+        process.stdout.write(`   ${c.dim("Saves:      ")}${detail.save_count}\n`);
+    }
+    if (detail.shared_with_emails?.length) {
+        process.stdout.write(`   ${c.dim("Shared:     ")}${detail.shared_with_emails.join(", ")}\n`);
+    }
+    process.stdout.write(`   ${c.dim("Created:    ")}${detail.created_at}\n`);
+    process.stdout.write(`   ${c.dim("Updated:    ")}${detail.updated_at}\n`);
+    process.stdout.write(`   ${c.dim("URL:        ")}${c.cyan(detail.url.replace(/\.md$/, ""))}\n\n`);
+}

package/dist/init.js

@@ -0,0 +1,59 @@
+import { writeFile, access } from "node:fs/promises";
+import { resolve, basename } from "node:path";
+import { createInterface } from "node:readline/promises";
+import { stdin as input, stdout as output } from "node:process";
+import { c, symbols } from "./ui.js";
+import { FloomError } from "./errors.js";
+const TEMPLATE = `---
+title:
+description:
+version: 1.0
+---
+
+# Goal
+
+
+# When to use
+
+
+# Inputs
+
+
+# Instructions
+
+
+# Output
+
+
+# Examples
+`;
+export async function init(filename) {
+    const target = filename ?? "skill.md";
+    const filePath = resolve(process.cwd(), target);
+    const exists = await fileExists(filePath);
+    if (exists) {
+        if (!process.stdin.isTTY) {
+            throw new FloomError(`${target} already exists.`, "Re-run with a different filename, or delete it first.");
+        }
+        const rl = createInterface({ input, output });
+        const answer = (await rl.question(`${c.yellow("?")}  ${target} already exists. Overwrite? ${c.dim("(y/N)")} `)).trim().toLowerCase();
+        rl.close();
+        if (answer !== "y" && answer !== "yes") {
+            process.stdout.write(`\n${c.dim("Cancelled. Nothing was written.")}\n\n`);
+            return;
+        }
+    }
+    await writeFile(filePath, TEMPLATE, "utf8");
+    process.stdout.write(`\n${symbols.ok}  Created ${c.bold(basename(filePath))}\n`);
+    process.stdout.write(`   ${c.dim("Fill in the title + description, then run:")}\n`);
+    process.stdout.write(`   ${c.cyan(`floom publish ${target}`)}\n\n`);
+}
+async function fileExists(p) {
+    try {
+        await access(p);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/install.js

@@ -0,0 +1,175 @@
+import { constants } from "node:fs";
+import { lstat, mkdir, open } from "node:fs/promises";
+import { createHash } from "node:crypto";
+import { homedir } from "node:os";
+import { basename, dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
+import ora from "ora";
+import { getApiUrl, readConfig } from "./config.js";
+import { getJson } from "./lib/api.js";
+import { c, symbols } from "./ui.js";
+import { FloomError } from "./errors.js";
+const SLUG_RE = /^[A-Za-z0-9_-]{1,128}$/;
+const FD_PATH_ROOT = "/proc/self/fd";
+function slugFromInput(input) {
+    const trimmed = input.trim();
+    try {
+        const url = new URL(trimmed);
+        const last = url.pathname.split("/").filter(Boolean).at(-1) ?? "";
+        return last.replace(/\.(md|json)$/i, "");
+    }
+    catch {
+        return trimmed.replace(/\.(md|json)$/i, "");
+    }
+}
+function skillsDir() {
+    return process.env.CLAUDE_SKILLS_DIR ?? join(homedir(), ".claude", "skills");
+}
+function skillPath(slug) {
+    return join(skillsDir(), `${slug}.md`);
+}
+function sha256(input) {
+    return createHash("sha256").update(input).digest("hex");
+}
+async function localHash(path) {
+    try {
+        const handle = await open(path, constants.O_RDONLY | constants.O_NOFOLLOW);
+        try {
+            const stat = await handle.stat();
+            if (!stat.isFile())
+                throw new FloomError("Local path is blocked by an existing file or directory.");
+            return sha256(await handle.readFile("utf8"));
+        }
+        finally {
+            await handle.close();
+        }
+    }
+    catch (err) {
+        const code = err.code;
+        if (code === "ENOENT")
+            return null;
+        if (code === "ELOOP")
+            throw new FloomError("Local path is a symbolic link.", "Move or delete the local path, then run `floom add` again.");
+        if (code === "ENOTDIR" || code === "EISDIR") {
+            throw new FloomError("Local path is blocked by an existing file or directory.");
+        }
+        throw err;
+    }
+}
+async function writeInstallFile(target, body) {
+    const parent = await openSafeParentDirectory(skillsDir(), target);
+    let handle = null;
+    try {
+        handle = await open(childCreatePath(parent, dirname(target), basename(target)), constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL | constants.O_NOFOLLOW, 0o600);
+        await writeAll(handle, body);
+    }
+    finally {
+        await handle?.close();
+        await parent.close();
+    }
+}
+async function openSafeParentDirectory(root, target) {
+    await ensureSafeParentDirectory(root, target);
+    return open(dirname(target), constants.O_RDONLY | constants.O_DIRECTORY | constants.O_NOFOLLOW);
+}
+function childCreatePath(parent, fallbackParent, name) {
+    if (process.platform === "linux")
+        return `${FD_PATH_ROOT}/${parent.fd}/${name}`;
+    return join(resolve(fallbackParent), name);
+}
+async function writeAll(handle, body) {
+    const buffer = Buffer.from(body, "utf8");
+    let offset = 0;
+    while (offset < buffer.length) {
+        const result = await handle.write(buffer, offset, buffer.length - offset, offset);
+        if (result.bytesWritten === 0)
+            throw new FloomError("Failed to write local skill file.");
+        offset += result.bytesWritten;
+    }
+}
+async function ensureSafeParentDirectory(root, target) {
+    const resolvedRoot = resolve(root);
+    const resolvedParent = resolve(dirname(target));
+    const relativeParent = relative(resolvedRoot, resolvedParent);
+    if (relativeParent === ".." || relativeParent.startsWith(`..${sep}`) || isAbsolute(relativeParent)) {
+        throw new FloomError("Invalid skill target path.");
+    }
+    await mkdir(resolvedRoot, { recursive: true, mode: 0o700 });
+    await assertSafeDirectory(resolvedRoot);
+    if (!relativeParent || relativeParent === ".")
+        return;
+    let current = resolvedRoot;
+    for (const segment of relativeParent.split(sep).filter(Boolean)) {
+        current = join(current, segment);
+        try {
+            await assertSafeDirectory(current);
+        }
+        catch (err) {
+            if (err.code !== "ENOENT")
+                throw err;
+            await mkdir(current, { mode: 0o700 });
+            await assertSafeDirectory(current);
+        }
+    }
+}
+async function assertSafeDirectory(path) {
+    const stat = await lstat(path);
+    if (stat.isSymbolicLink()) {
+        throw new FloomError("Local path contains a symbolic link.", "Move or delete the local path, then run `floom add` again.");
+    }
+    if (!stat.isDirectory()) {
+        throw new FloomError("Local path is blocked by an existing file or directory.");
+    }
+}
+export async function install(slugInput) {
+    const slug = slugFromInput(slugInput);
+    if (!SLUG_RE.test(slug)) {
+        throw new FloomError(`Invalid skill slug: ${slugInput}`);
+    }
+    const cfg = await readConfig();
+    const apiUrl = cfg?.apiUrl ?? getApiUrl();
+    const spinner = ora({ text: c.dim(`Adding ${slug}...`), color: "yellow" }).start();
+    let detail;
+    try {
+        detail = await getJson(`${apiUrl}/api/v1/skills/${encodeURIComponent(slug)}`, "fetch skill", cfg?.accessToken);
+        if (!detail || typeof detail.body_md !== "string") {
+            throw new FloomError("Invalid skill response.");
+        }
+    }
+    catch (err) {
+        spinner.stop();
+        throw err;
+    }
+    await mkdir(skillsDir(), { recursive: true, mode: 0o700 });
+    const target = skillPath(slug);
+    const remoteHash = sha256(detail.body_md);
+    const existing = await localHash(target);
+    let action;
+    if (existing === remoteHash) {
+        action = "unchanged";
+    }
+    else if (existing !== null) {
+        throw new FloomError("Local skill already exists with different content.", "Move or delete the local file, then run `floom add` again.");
+    }
+    else {
+        try {
+            await writeInstallFile(target, detail.body_md);
+        }
+        catch (err) {
+            const code = err.code;
+            if (code === "EEXIST") {
+                throw new FloomError("Local skill already exists with different content.", "Move or delete the local file, then run `floom add` again.");
+            }
+            if (code === "ELOOP") {
+                throw new FloomError("Local path is a symbolic link.", "Move or delete the local path, then run `floom add` again.");
+            }
+            if (code === "ENOENT") {
+                throw new FloomError("Local path changed during install.", "Run `floom add` again.");
+            }
+            throw err;
+        }
+        action = "installed";
+    }
+    spinner.stop();
+    process.stdout.write(`\n${symbols.ok}  [floom] ${action} ${c.bold(slug)}\n`);
+    process.stdout.write(`   ${c.dim(target)}\n\n`);
+}

package/dist/lib/api.js

@@ -0,0 +1,58 @@
+import { friendlyHttp, friendlyNetwork, FloomError } from "../errors.js";
+/**
+ * Shared HTTP helpers for CLI commands. Mirrors the mcp-sync/lib/api.ts
+ * patterns but throws FloomError instances so the CLI's printError gives
+ * users a clean message instead of a stack trace.
+ */
+const DEFAULT_TIMEOUT_MS = 15_000;
+async function floomFetch(url, action, opts = {}) {
+    const headers = {};
+    if (opts.token)
+        headers.authorization = `Bearer ${opts.token}`;
+    if (opts.body !== undefined)
+        headers["content-type"] = "application/json";
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), opts.timeoutMs ?? DEFAULT_TIMEOUT_MS);
+    let res;
+    try {
+        res = await fetch(url, {
+            method: opts.method ?? "GET",
+            headers,
+            signal: controller.signal,
+            ...(opts.body !== undefined ? { body: JSON.stringify(opts.body) } : {}),
+        });
+    }
+    catch (err) {
+        if (err.name === "AbortError") {
+            throw new FloomError(`Request timed out while trying to ${action}.`, "Try again in a moment.");
+        }
+        throw friendlyNetwork(err);
+    }
+    finally {
+        clearTimeout(timer);
+    }
+    if (!res.ok) {
+        throw friendlyHttp(res.status, action);
+    }
+    return res;
+}
+export async function getJson(url, action, token) {
+    const res = await floomFetch(url, action, token ? { token } : {});
+    return (await res.json());
+}
+export async function getText(url, action, token) {
+    const res = await floomFetch(url, action, token ? { token } : {});
+    return res.text();
+}
+export async function postJson(url, action, token, body) {
+    const res = await floomFetch(url, action, { method: "POST", token, body });
+    return (await res.json());
+}
+export async function deleteRequest(url, action, token) {
+    const res = await floomFetch(url, action, { method: "DELETE", token });
+    return (await res.json());
+}
+export async function putJson(url, action, token, body) {
+    const res = await floomFetch(url, action, { method: "PUT", token, body });
+    return (await res.json());
+}