@floomhq/floom 1.0.64 → 2.0.1

package/dist/config.js

@@ -1,85 +0,0 @@
-import { homedir } from "node:os";
-import { dirname, join } from "node:path";
-import { mkdir, readFile, writeFile, chmod, unlink } from "node:fs/promises";
-export const CONFIG_DIR = join(homedir(), ".floom");
-export const CONFIG_PATH = join(CONFIG_DIR, "config.json");
-export const DEFAULT_API_URL = "https://floom.dev";
-export const DEFAULT_WEB_URL = "https://floom.dev";
-export function getApiUrl() {
-    return process.env.FLOOM_API_URL?.replace(/\/$/, "") ?? DEFAULT_API_URL;
-}
-export function resolveApiUrl(cfg) {
-    return process.env.FLOOM_API_URL?.replace(/\/$/, "") ?? cfg?.apiUrl?.replace(/\/$/, "") ?? DEFAULT_API_URL;
-}
-export function getWebUrl() {
-    return process.env.FLOOM_WEB_URL?.replace(/\/$/, "") ?? DEFAULT_WEB_URL;
-}
-export async function readConfig() {
-    try {
-        const buf = await readFile(process.env.FLOOM_CONFIG_PATH ?? CONFIG_PATH, "utf8");
-        const parsed = JSON.parse(buf);
-        if (!parsed.accessToken || !parsed.refreshToken)
-            return null;
-        return refreshConfigIfNeeded(parsed);
-    }
-    catch (e) {
-        if (e.code === "ENOENT")
-            return null;
-        throw e;
-    }
-}
-export async function refreshConfigIfNeeded(cfg, opts = {}) {
-    const now = Math.floor(Date.now() / 1000);
-    if (!opts.force && (typeof cfg.expiresAt !== "number" || cfg.expiresAt > now + 120))
-        return cfg;
-    try {
-        const refreshed = await refreshConfig(cfg);
-        await writeConfig(refreshed);
-        return refreshed;
-    }
-    catch {
-        return cfg;
-    }
-}
-async function refreshConfig(cfg) {
-    const apiUrl = resolveApiUrl(cfg);
-    const res = await fetch(`${apiUrl}/api/auth/refresh`, {
-        method: "POST",
-        headers: { "content-type": "application/json" },
-        body: JSON.stringify({ refresh_token: cfg.refreshToken }),
-    });
-    if (!res.ok)
-        throw new Error(`refresh failed with ${res.status}`);
-    const data = (await res.json());
-    if (!data.access_token || !data.refresh_token)
-        throw new Error("refresh response missing tokens");
-    const expiresIn = Number(data.expires_in ?? "3600");
-    return {
-        ...cfg,
-        accessToken: data.access_token,
-        refreshToken: data.refresh_token,
-        expiresAt: Math.floor(Date.now() / 1000) + (Number.isFinite(expiresIn) ? expiresIn : 3600),
-        ...(typeof data.email === "string" || data.email === null
-            ? { email: data.email }
-            : typeof cfg.email === "string" || cfg.email === null
-                ? { email: cfg.email }
-                : {}),
-    };
-}
-export async function writeConfig(cfg) {
-    const targetPath = process.env.FLOOM_CONFIG_PATH ?? CONFIG_PATH;
-    const targetDir = dirname(targetPath);
-    await mkdir(targetDir, { recursive: true, mode: 0o700 });
-    await writeFile(targetPath, JSON.stringify(cfg, null, 2), { mode: 0o600 });
-    // belt-and-suspenders: set perms in case the file already existed
-    await chmod(targetPath, 0o600);
-}
-export async function deleteConfig() {
-    try {
-        await unlink(process.env.FLOOM_CONFIG_PATH ?? CONFIG_PATH);
-    }
-    catch (e) {
-        if (e.code !== "ENOENT")
-            throw e;
-    }
-}

package/dist/daemon.js

@@ -1,450 +0,0 @@
-import { spawn } from "node:child_process";
-import { access, appendFile, mkdir, readFile, unlink, writeFile } from "node:fs/promises";
-import { homedir, hostname, platform } from "node:os";
-import { dirname, join } from "node:path";
-import { CONFIG_DIR } from "./config.js";
-import { CLI_VERSION } from "./version.js";
-import { FloomError } from "./errors.js";
-import { c, symbols } from "./ui.js";
-import { AGENT_TARGETS, isAgentTarget, targetSkillsDirEnv } from "./targets.js";
-const SERVICE_NAME = "floom-sync.service";
-const LAUNCHD_LABEL = "dev.floom.sync";
-const LOG_PATH = join(CONFIG_DIR, "daemon.log");
-const STATUS_PATH = join(CONFIG_DIR, "daemon-status.json");
-const NATIVE_BASELINE_VERSION = 4;
-const MIN_INTERVAL_SECONDS = 30;
-const MIN_TIMEOUT_SECONDS = 30;
-function targetsFor(value) {
-    return value === "all" ? [...AGENT_TARGETS] : [value];
-}
-function cliInvocation() {
-    const override = process.env.FLOOM_DAEMON_CLI_COMMAND?.trim();
-    if (override)
-        return override;
-    return `npx -y @floomhq/floom@${CLI_VERSION}`;
-}
-function shellQuote(value) {
-    return `'${value.replace(/'/g, "'\\''")}'`;
-}
-function runCommand(args, extraEnv = {}) {
-    const timeoutMs = Math.max(MIN_TIMEOUT_SECONDS, Number(args[0]) || MIN_TIMEOUT_SECONDS) * 1000;
-    const commandArgs = args.slice(1);
-    return new Promise((resolve) => {
-        const child = spawn(process.execPath, [process.argv[1] ?? "", ...commandArgs], {
-            env: {
-                ...process.env,
-                ...extraEnv,
-                NO_UPDATE_NOTIFIER: "1",
-                npm_config_update_notifier: "false",
-            },
-            stdio: ["ignore", "pipe", "pipe"],
-        });
-        let stdout = "";
-        let stderr = "";
-        let timedOut = false;
-        const timer = setTimeout(() => {
-            timedOut = true;
-            child.kill("SIGTERM");
-            setTimeout(() => child.kill("SIGKILL"), 5000).unref();
-        }, timeoutMs);
-        child.stdout.setEncoding("utf8");
-        child.stderr.setEncoding("utf8");
-        child.stdout.on("data", (chunk) => { stdout += chunk; });
-        child.stderr.on("data", (chunk) => { stderr += chunk; });
-        child.on("close", (code) => {
-            clearTimeout(timer);
-            resolve({ code: code ?? 1, stdout, stderr, timedOut });
-        });
-    });
-}
-async function appendLog(message) {
-    await mkdir(CONFIG_DIR, { recursive: true, mode: 0o700 });
-    await appendFile(LOG_PATH, message, { mode: 0o600 });
-}
-async function writeStatus(status) {
-    await mkdir(CONFIG_DIR, { recursive: true, mode: 0o700 });
-    await writeFile(STATUS_PATH, `${JSON.stringify(status, null, 2)}\n`, { mode: 0o600 });
-}
-async function readStatus() {
-    try {
-        return JSON.parse(await readFile(STATUS_PATH, "utf8"));
-    }
-    catch (err) {
-        if (err.code === "ENOENT")
-            return null;
-        throw err;
-    }
-}
-function pidIsAlive(pid) {
-    if (!pid || pid < 1)
-        return false;
-    try {
-        process.kill(pid, 0);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-function statusIsLive(status) {
-    if (!status?.running)
-        return false;
-    if (!pidIsAlive(status.pid))
-        return false;
-    if (!status.next_run_at || !status.interval_seconds)
-        return true;
-    const nextRun = Date.parse(status.next_run_at);
-    if (!Number.isFinite(nextRun))
-        return false;
-    const graceMs = Math.max(status.interval_seconds * 2000, 120_000);
-    return nextRun + graceMs >= Date.now();
-}
-function parseSyncResult(output) {
-    const match = output.match(/synced\s+(\d+)\s+skills\s+\((\d+)\s+unchanged,\s+(\d+)\s+updated(?:,\s+(\d+)\s+conflicts?\s+skipped)?/i);
-    if (!match)
-        return {};
-    return {
-        synced: Number(match[1]),
-        updated: Number(match[3]),
-        conflicts: Number(match[4] ?? "0"),
-    };
-}
-async function runTarget(target, opts) {
-    const started = Date.now();
-    const cacheDir = join(CONFIG_DIR, "skill-cache", target);
-    const nativeManifestPath = join(CONFIG_DIR, "native-sync-manifests", `${target}.json`);
-    const syncResult = await runCommand([String(opts.timeoutSeconds), "sync", "--target", target], {
-        [targetSkillsDirEnv(target)]: cacheDir,
-        FLOOM_SYNC_MANIFEST_PATH: join(cacheDir, ".floom-cli-sync-manifest.json"),
-    });
-    const combined = `${syncResult.stdout}\n${syncResult.stderr}`;
-    let ok = syncResult.code === 0 && !syncResult.timedOut;
-    let error = syncResult.timedOut ? "sync timed out" : syncResult.code === 0 ? undefined : combined.trim() || "sync failed";
-    if (ok) {
-        const setupResult = await runCommand([String(opts.timeoutSeconds), "setup", "--target", target, "--yes", "--global"]);
-        if (setupResult.code !== 0 || setupResult.timedOut) {
-            ok = false;
-            error = setupResult.timedOut ? "instruction setup timed out" : `${setupResult.stdout}\n${setupResult.stderr}`.trim() || "instruction setup failed";
-        }
-    }
-    if (opts.push && ok) {
-        if (opts.yolo && !(await fileExists(nativeBaselinePath(target)))) {
-            const baselineResult = await runCommand([String(opts.timeoutSeconds), "watch", "--push", "--once", "--target", target, "--no-yolo"], { FLOOM_SYNC_MANIFEST_PATH: nativeManifestPath, FLOOM_BASELINE_ADOPT_ALL: "1" });
-            if (baselineResult.code !== 0 || baselineResult.timedOut) {
-                ok = false;
-                error = baselineResult.timedOut ? "native baseline timed out" : `${baselineResult.stdout}\n${baselineResult.stderr}`.trim() || "native baseline failed";
-            }
-            else {
-                await writeNativeBaselineMarker(target);
-            }
-        }
-    }
-    if (opts.push && ok) {
-        const pushArgs = ["watch", "--push", "--once", "--target", target];
-        if (!opts.yolo)
-            pushArgs.push("--no-yolo");
-        const pushResult = await runCommand([String(opts.timeoutSeconds), ...pushArgs], { FLOOM_SYNC_MANIFEST_PATH: nativeManifestPath });
-        if (pushResult.code !== 0 || pushResult.timedOut) {
-            ok = false;
-            error = pushResult.timedOut ? "push timed out" : `${pushResult.stdout}\n${pushResult.stderr}`.trim() || "push failed";
-        }
-    }
-    await appendLog([
-        `${new Date().toISOString()} target=${target} ok=${ok}`,
-        combined.trim(),
-        error && !combined.includes(error) ? error : "",
-        "",
-    ].filter(Boolean).join("\n"));
-    return {
-        ok,
-        ...parseSyncResult(combined),
-        ...(error ? { error } : {}),
-        duration_ms: Date.now() - started,
-    };
-}
-async function fileExists(path) {
-    try {
-        await access(path);
-        return true;
-    }
-    catch (err) {
-        if (err.code === "ENOENT")
-            return false;
-        throw err;
-    }
-}
-function nativeBaselinePath(target) {
-    return join(CONFIG_DIR, "native-sync-manifests", `${target}.baseline-v${NATIVE_BASELINE_VERSION}.json`);
-}
-async function writeNativeBaselineMarker(target) {
-    const path = nativeBaselinePath(target);
-    await mkdir(dirname(path), { recursive: true, mode: 0o700 });
-    await writeFile(path, `${JSON.stringify({
-        version: NATIVE_BASELINE_VERSION,
-        target,
-        created_at: new Date().toISOString(),
-    }, null, 2)}\n`, { mode: 0o600 });
-}
-async function sleep(ms) {
-    await new Promise((resolve) => setTimeout(resolve, ms));
-}
-export async function runDaemonForeground(opts) {
-    const targets = targetsFor(opts.target);
-    process.stdout.write(`${symbols.bullet}  Floom daemon running for ${targets.join(", ")} every ${opts.intervalSeconds}s.\n`);
-    for (;;) {
-        const now = new Date();
-        const status = {
-            running: true,
-            manager: "foreground",
-            service: "foreground",
-            pid: process.pid,
-            version: CLI_VERSION,
-            hostname: hostname(),
-            interval_seconds: opts.intervalSeconds,
-            timeout_seconds: opts.timeoutSeconds,
-            targets,
-            push: opts.push,
-            yolo: opts.yolo,
-            last_started_at: now.toISOString(),
-            last_run: {},
-        };
-        await writeStatus(status);
-        for (const target of targets) {
-            status.last_run[target] = await runTarget(target, opts);
-            await writeStatus(status);
-        }
-        const completed = new Date();
-        status.last_completed_at = completed.toISOString();
-        status.next_run_at = new Date(completed.getTime() + opts.intervalSeconds * 1000).toISOString();
-        await writeStatus(status);
-        await appendLog(`${completed.toISOString()} daemon cycle complete\n`);
-        if (!opts.foreground)
-            return;
-        await sleep(opts.intervalSeconds * 1000);
-    }
-}
-function serviceCommand(opts) {
-    const args = [
-        "daemon",
-        "run",
-        "--foreground",
-        "--target",
-        opts.target,
-        "--interval",
-        String(opts.intervalSeconds),
-        "--timeout",
-        String(opts.timeoutSeconds),
-        opts.push ? "--push" : "--no-push",
-        opts.yolo ? "--yolo" : "--no-yolo",
-    ];
-    return `exec ${cliInvocation()} ${args.map(shellQuote).join(" ")}`;
-}
-function systemdUnit(opts, user) {
-    return `[Unit]
-Description=Floom always-on skill sync
-After=network-online.target
-Wants=network-online.target
-
-[Service]
-Type=simple
-ExecStart=/bin/sh -lc ${shellQuote(serviceCommand(opts))}
-Restart=always
-RestartSec=15
-Environment=NO_UPDATE_NOTIFIER=1
-Environment=npm_config_update_notifier=false
-
-[Install]
-WantedBy=${user ? "default.target" : "multi-user.target"}
-`;
-}
-function launchdPlist(opts) {
-    const command = serviceCommand(opts);
-    return `<?xml version="1.0" encoding="UTF-8"?>
-<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
-<plist version="1.0">
-<dict>
-  <key>Label</key>
-  <string>${LAUNCHD_LABEL}</string>
-  <key>ProgramArguments</key>
-  <array>
-    <string>/bin/sh</string>
-    <string>-lc</string>
-    <string>${escapePlist(command)}</string>
-  </array>
-  <key>RunAtLoad</key>
-  <true/>
-  <key>KeepAlive</key>
-  <true/>
-  <key>StandardOutPath</key>
-  <string>${LOG_PATH}</string>
-  <key>StandardErrorPath</key>
-  <string>${LOG_PATH}</string>
-</dict>
-</plist>
-`;
-}
-function escapePlist(value) {
-    return value
-        .replace(/&/g, "&amp;")
-        .replace(/</g, "&lt;")
-        .replace(/>/g, "&gt;");
-}
-function manager() {
-    return platform() === "darwin" ? "launchd" : "systemd";
-}
-function systemdPath() {
-    const isRoot = typeof process.getuid === "function" && process.getuid() === 0;
-    if (isRoot)
-        return { path: `/etc/systemd/system/${SERVICE_NAME}`, user: false };
-    return { path: join(homedir(), ".config", "systemd", "user", SERVICE_NAME), user: true };
-}
-async function installDaemon(opts) {
-    if (manager() === "launchd") {
-        const plistPath = join(homedir(), "Library", "LaunchAgents", `${LAUNCHD_LABEL}.plist`);
-        const body = launchdPlist(opts);
-        if (opts.dryRun) {
-            process.stdout.write(body);
-            return;
-        }
-        await mkdir(dirname(plistPath), { recursive: true });
-        await writeFile(plistPath, body, "utf8");
-        process.stdout.write(`${symbols.ok}  Installed ${plistPath}\n`);
-        await runManagerCommand("launchctl", ["bootstrap", `gui/${process.getuid?.() ?? ""}`, plistPath], true);
-        await runManagerCommand("launchctl", ["kickstart", "-k", `gui/${process.getuid?.() ?? ""}/${LAUNCHD_LABEL}`], true);
-        return;
-    }
-    const target = systemdPath();
-    const body = systemdUnit(opts, target.user);
-    if (opts.dryRun) {
-        process.stdout.write(body);
-        return;
-    }
-    await mkdir(dirname(target.path), { recursive: true });
-    await writeFile(target.path, body, "utf8");
-    process.stdout.write(`${symbols.ok}  Installed ${target.path}\n`);
-    await runSystemctl(["daemon-reload"], target.user, true);
-    await runSystemctl(["enable", "--now", SERVICE_NAME], target.user, true);
-}
-async function showStatus(opts) {
-    const status = await readStatus();
-    const live = statusIsLive(status);
-    if (opts.json) {
-        process.stdout.write(`${JSON.stringify(status ? { ...status, running: live } : { running: false }, null, 2)}\n`);
-        return;
-    }
-    if (!status) {
-        process.stdout.write(`${symbols.bullet}  Floom daemon has no status yet.\n`);
-        return;
-    }
-    process.stdout.write(`${live ? symbols.ok : symbols.bullet}  Floom daemon ${live ? "status" : "last status"}\n`);
-    process.stdout.write(`   ${c.dim("manager:")} ${status.manager}\n`);
-    process.stdout.write(`   ${c.dim("targets:")} ${status.targets.join(", ")}\n`);
-    if (status.last_completed_at)
-        process.stdout.write(`   ${c.dim("last completed:")} ${status.last_completed_at}\n`);
-    for (const [target, run] of Object.entries(status.last_run)) {
-        process.stdout.write(`   ${run.ok ? symbols.ok : symbols.fail} ${target}: ${run.ok ? "ok" : run.error ?? "failed"}\n`);
-    }
-}
-async function showLogs(opts) {
-    const body = await readFile(LOG_PATH, "utf8").catch((err) => {
-        if (err.code === "ENOENT")
-            return "";
-        throw err;
-    });
-    const lines = body.split(/\r?\n/);
-    process.stdout.write(`${lines.slice(Math.max(0, lines.length - opts.tail)).join("\n")}\n`);
-}
-function execManager(command, args) {
-    return new Promise((resolve) => {
-        const child = spawn(command, args, { stdio: ["ignore", "ignore", "pipe"] });
-        let stderr = "";
-        child.stderr.setEncoding("utf8");
-        child.stderr.on("data", (chunk) => { stderr += chunk; });
-        child.on("error", (err) => resolve({ code: 127, stderr: err.message }));
-        child.on("close", (code) => resolve({ code: code ?? 1, stderr }));
-    });
-}
-async function runManagerCommand(command, args, soft) {
-    const result = await execManager(command, args);
-    if (result.code === 0)
-        return;
-    const rendered = `${command} ${args.join(" ")}`;
-    if (soft) {
-        process.stdout.write(`   ${c.dim(`Run manually if needed: ${rendered}`)}\n`);
-        return;
-    }
-    throw new FloomError(`Failed to run ${rendered}.`, result.stderr.trim() || "Service manager command failed.");
-}
-async function runSystemctl(args, user, soft) {
-    await runManagerCommand("systemctl", user ? ["--user", ...args] : args, soft);
-}
-async function restartDaemon() {
-    if (manager() === "launchd") {
-        await runManagerCommand("launchctl", ["kickstart", "-k", `gui/${process.getuid?.() ?? ""}/${LAUNCHD_LABEL}`], false);
-        process.stdout.write(`${symbols.ok}  Restarted ${LAUNCHD_LABEL}\n`);
-        return;
-    }
-    const target = systemdPath();
-    await runSystemctl(["restart", SERVICE_NAME], target.user, false);
-    process.stdout.write(`${symbols.ok}  Restarted ${SERVICE_NAME}\n`);
-}
-async function uninstallDaemon() {
-    if (manager() === "launchd") {
-        const plistPath = join(homedir(), "Library", "LaunchAgents", `${LAUNCHD_LABEL}.plist`);
-        await runManagerCommand("launchctl", ["bootout", `gui/${process.getuid?.() ?? ""}/${LAUNCHD_LABEL}`], true);
-        await unlink(plistPath).catch((err) => {
-            if (err.code !== "ENOENT")
-                throw err;
-        });
-        process.stdout.write(`${symbols.ok}  Uninstalled ${LAUNCHD_LABEL}\n`);
-        return;
-    }
-    const target = systemdPath();
-    await runSystemctl(["disable", "--now", SERVICE_NAME], target.user, true);
-    await unlink(target.path).catch((err) => {
-        if (err.code !== "ENOENT")
-            throw err;
-    });
-    await runSystemctl(["daemon-reload"], target.user, true);
-    process.stdout.write(`${symbols.ok}  Uninstalled ${SERVICE_NAME}\n`);
-}
-export async function daemon(opts) {
-    switch (opts.command) {
-        case "install":
-            await installDaemon(opts);
-            return;
-        case "status":
-            await showStatus(opts);
-            return;
-        case "logs":
-            await showLogs(opts);
-            return;
-        case "run":
-            await runDaemonForeground(opts);
-            return;
-        case "restart":
-            await restartDaemon();
-            return;
-        case "uninstall":
-            await uninstallDaemon();
-            return;
-        default:
-            throw new FloomError("Missing daemon command.", "Use install, status, logs, restart, uninstall, or run.");
-    }
-}
-export function normalizeDaemonOptions(opts) {
-    if (opts.intervalSeconds < MIN_INTERVAL_SECONDS) {
-        throw new FloomError("Invalid --interval.", `Use an integer number of seconds, minimum ${MIN_INTERVAL_SECONDS}.`);
-    }
-    if (opts.timeoutSeconds < MIN_TIMEOUT_SECONDS) {
-        throw new FloomError("Invalid --timeout.", `Use an integer number of seconds, minimum ${MIN_TIMEOUT_SECONDS}.`);
-    }
-    return opts;
-}
-export function parseDaemonTarget(value) {
-    if (value === "all")
-        return "all";
-    if (isAgentTarget(value))
-        return value;
-    throw new FloomError("Invalid --target.", "Use claude|codex|cursor|opencode|kimi|all.");
-}

package/dist/delete.js

@@ -1,55 +0,0 @@
-import { createInterface } from "node:readline/promises";
-import { stdin as input, stdout as output } from "node:process";
-import ora from "ora";
-import { readConfig, resolveApiUrl } from "./config.js";
-import { deleteRequest } from "./lib/api.js";
-import { c, symbols } from "./ui.js";
-import { FloomError } from "./errors.js";
-function slugFromInput(s) {
-    const trimmed = s.trim();
-    try {
-        const url = new URL(trimmed);
-        return (url.pathname.split("/").filter(Boolean).at(-1) ?? "").replace(/\.(md|json)$/i, "");
-    }
-    catch {
-        return trimmed.replace(/\.(md|json)$/i, "");
-    }
-}
-async function confirm(question) {
-    if (!process.stdin.isTTY) {
-        throw new FloomError("Refusing to delete without confirmation in non-interactive mode.", "Pass `--yes` to skip the prompt.");
-    }
-    const rl = createInterface({ input, output });
-    try {
-        const answer = (await rl.question(`   ${question} (y/N) `)).trim().toLowerCase();
-        return answer === "y" || answer === "yes";
-    }
-    finally {
-        rl.close();
-    }
-}
-export async function deleteSkill(opts) {
-    const slug = slugFromInput(opts.slug);
-    if (!slug)
-        throw new FloomError("Missing skill slug.", "Try: `npx -y @floomhq/floom delete <slug>`");
-    const cfg = await readConfig();
-    if (!cfg)
-        throw new FloomError("Not signed in.", "Run `npx -y @floomhq/floom login` first.");
-    if (!opts.yes) {
-        process.stdout.write(`\n${symbols.bullet}  About to delete ${c.bold(slug)}.\n`);
-        const ok = await confirm(`Delete ${c.bold(slug)}? Cannot be undone in CLI.`);
-        if (!ok) {
-            process.stdout.write(`\n${c.dim("Cancelled.")}\n\n`);
-            return;
-        }
-    }
-    const apiUrl = resolveApiUrl(cfg);
-    const spinner = ora({ text: c.dim(`Deleting ${slug}...`), color: "yellow" }).start();
-    try {
-        await deleteRequest(`${apiUrl}/api/v1/skills/${encodeURIComponent(slug)}`, "delete skill", cfg.accessToken);
-    }
-    finally {
-        spinner.stop();
-    }
-    process.stdout.write(`\n${symbols.ok}  Deleted ${c.bold(slug)}\n\n`);
-}