@tpsdev-ai/flair 0.52.0 → 0.54.1

package/dist/commands/test.js

@@ -0,0 +1,93 @@
+import * as render from "../render.js";
+let cli;
+/** Bind the cli-locals this module depends on. */
+export function bindCli(fns) {
+    cli = fns;
+}
+function api(...args) {
+    return cli.api(...args);
+}
+function resolveBaseUrl(...args) {
+    return cli.resolveBaseUrl(...args);
+}
+export function register(program) {
+    // ─── flair test ───────────────────────────────────────────────────────────────
+    program
+        .command("test")
+        .description("Verify the full Flair stack: write, search, and delete a test memory")
+        .option("--agent <id>", "Agent ID (or set FLAIR_AGENT_ID env)")
+        .option("--port <port>", "Harper HTTP port")
+        .action(async (opts) => {
+        const agentId = opts.agent ?? process.env.FLAIR_AGENT_ID;
+        if (!agentId && !process.env.FLAIR_ADMIN_PASS) {
+            console.error(`${render.icons.error} ${render.wrap(render.c.red, "set --agent / FLAIR_AGENT_ID or FLAIR_ADMIN_PASS")}`);
+            process.exit(1);
+        }
+        // Single source of truth (flair#1351): banner prints the URL the test's
+        // own client uses. resolveBaseUrl is the existing CLI resolver; pass the
+        // same value through to api() so the two cannot diverge.
+        const baseUrl = resolveBaseUrl(opts);
+        console.log(`\n${render.wrap(render.c.bold, "Flair test")} ${render.wrap(render.c.dim, `(url: ${baseUrl})`)}\n`);
+        let passed = 0;
+        let failed = 0;
+        let memoryId = null;
+        const check = async (name, fn) => {
+            try {
+                const ok = await fn();
+                if (ok) {
+                    console.log(`  ${render.icons.ok} ${render.wrap(render.c.green, "PASS")} ${name}`);
+                    passed++;
+                }
+                else {
+                    console.log(`  ${render.icons.error} ${render.wrap(render.c.red, "FAIL")} ${name}`);
+                    failed++;
+                }
+            }
+            catch (e) {
+                const message = e instanceof Error ? e.message : String(e);
+                console.log(`  ${render.icons.error} ${render.wrap(render.c.red, "FAIL")} ${name}: ${render.wrap(render.c.dim, message?.slice(0, 120))}`);
+                failed++;
+            }
+        };
+        // 1. Write a test memory via PUT /Memory/<id>.
+        // Schema only exposes PUT — POST returns 'Memory does not have a post method implemented'.
+        await check("Write test memory (PUT /Memory/<id>)", async () => {
+            const id = `flair-test-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+            const body = {
+                id,
+                content: "flair test \u2014 this will be deleted",
+                durability: "ephemeral",
+                createdAt: new Date().toISOString(),
+            };
+            if (agentId)
+                body.agentId = agentId;
+            await api("PUT", `/Memory/${id}`, body, { baseUrl });
+            memoryId = id;
+            return true;
+        });
+        // 2. Search for the test memory via POST /SemanticSearch
+        await check("Search for test memory (POST /SemanticSearch)", async () => {
+            await new Promise(r => setTimeout(r, 1500)); // allow indexing
+            const body = { q: "flair test", limit: 5 };
+            if (agentId)
+                body.agentId = agentId;
+            const result = await api("POST", "/SemanticSearch", body, { baseUrl });
+            return (result?.results?.length ?? 0) > 0;
+        });
+        // 3. Delete the test memory via DELETE /Memory/<id>
+        await check("Delete test memory (DELETE /Memory/<id>)", async () => {
+            if (!memoryId) {
+                // If write returned ok without an id, skip deletion cleanly
+                console.log(`       (skipped — no id returned from write step)`);
+                return true;
+            }
+            await api("DELETE", `/Memory/${memoryId}`, agentId ? { agentId } : undefined, { baseUrl });
+            return true;
+        });
+        const passColor = passed > 0 ? render.c.green : render.c.dim;
+        const failColor = failed > 0 ? render.c.red : render.c.dim;
+        console.log(`\n  ${render.wrap(passColor, `${passed} passed`)} ${render.wrap(render.c.dim, "·")} ${render.wrap(failColor, `${failed} failed`)}`);
+        if (failed > 0)
+            process.exit(1);
+    });
+}

package/dist/commands/uninstall.js

@@ -0,0 +1,143 @@
+import { formatPurgeReport, purgeFlairInstall, purgeHadFailures } from "../lib/uninstall-purge.js";
+import { existsSync, unlinkSync } from "node:fs";
+import { homedir } from "node:os";
+let cli;
+/** Bind the cli-locals this module depends on. */
+export function bindCli(fns) {
+    cli = fns;
+}
+function configPath(...args) {
+    return cli.configPath(...args);
+}
+function defaultDataDir(...args) {
+    return cli.defaultDataDir(...args);
+}
+function launchdLabel(...args) {
+    return cli.launchdLabel(...args);
+}
+function launchdPlistPath(...args) {
+    return cli.launchdPlistPath(...args);
+}
+function listeningPidsOnPort(...args) {
+    return cli.listeningPidsOnPort(...args);
+}
+function readHarperPid(...args) {
+    return cli.readHarperPid(...args);
+}
+function resolveHttpPort(...args) {
+    return cli.resolveHttpPort(...args);
+}
+export function register(program) {
+    const LEGACY_LAUNCHD_LABEL = cli.LEGACY_LAUNCHD_LABEL;
+    // ─── flair uninstall ──────────────────────────────────────────────────────────
+    program
+        .command("uninstall")
+        .description("Stop Flair and remove the launchd/systemd service")
+        .option("--purge", "Also remove data, keys, secrets, schedulers, and client wiring (destructive)")
+        .action(async (opts) => {
+        const platform = process.platform;
+        // Use the unified resolver: Harper's config > per-user config > default.
+        // A default of 19926 that is "present but wrong" beats the actual port
+        // Harper is serving on (flair#819). resolveHttpPort reads Harper's own
+        // config in the data directory, which is authoritative.
+        const port = resolveHttpPort({}, "address");
+        // Stop first: remove launchd service(s) on macOS, then kill by port on
+        // all platforms. Removes BOTH the new instance-scoped plist and a
+        // pre-flair#693 legacy plist if present — uninstall's job is to purge
+        // everything for this data dir, so it doesn't rely on resolveLaunchdLabel's
+        // "prefer new" pick alone (which would skip a stray legacy leftover).
+        if (platform === "darwin") {
+            const dataDir = defaultDataDir();
+            const candidatePlists = [launchdPlistPath(launchdLabel(dataDir)), launchdPlistPath(LEGACY_LAUNCHD_LABEL)];
+            let removedAny = false;
+            for (const plistPath of candidatePlists) {
+                if (existsSync(plistPath)) {
+                    try {
+                        const { execSync } = await import("node:child_process");
+                        execSync(`launchctl unload "${plistPath}"`, { stdio: "pipe" });
+                    }
+                    catch { /* best effort */ }
+                    unlinkSync(plistPath);
+                    removedAny = true;
+                }
+            }
+            if (removedAny)
+                console.log("✅ Launchd service removed");
+        }
+        // Kill any process still on the port (covers direct-start, no-service, or
+        // failed unload). Listening sockets only, never our own PID — see
+        // parseListeningPids (flair#800/flair#905).
+        //
+        // Guard (flair#917): refuse to SIGTERM a PID that cannot be attributed to
+        // this Flair instance. A port is not an identity — something else can hold
+        // it. Killing the wrong PID and then purging data is the whole bug.
+        let refusedKill = false;
+        try {
+            const { execSync } = await import("node:child_process");
+            const pids = listeningPidsOnPort(port, (cmd) => execSync(cmd, { encoding: "utf-8" }));
+            if (pids.length > 0) {
+                // Verify ownership before killing: the PID must match this instance's
+                // recorded PID (hdb.pid). If no PID file exists, Harper is already
+                // stopped and the port is stale — safe to skip.
+                const dataDir = defaultDataDir();
+                const harperPid = readHarperPid(dataDir);
+                if (harperPid !== null) {
+                    // PID file exists — the PID on the port must be Harper or we refuse.
+                    if (!pids.includes(harperPid)) {
+                        console.log(`⚠️  Process(es) on port ${port} (PID${pids.length > 1 ? "s" : ""}: ${pids.join(", ")}) `
+                            + `do not match this Flair instance (PID ${harperPid}). `
+                            + `Not killing — cannot attribute the process to this instance. `
+                            + `Stop the process manually if it is not Flair.`);
+                        refusedKill = true;
+                    }
+                    else {
+                        for (const pid of pids) {
+                            try {
+                                process.kill(pid, "SIGTERM");
+                            }
+                            catch { }
+                        }
+                        await new Promise(r => setTimeout(r, 2000));
+                        console.log("✅ Flair process stopped");
+                    }
+                }
+                else {
+                    // No PID file — Harper is not (or was not) running here.
+                    // The port may be stale or held by something else; don't risk killing it.
+                    console.log(`⚠️  Process(es) on port ${port} (PID${pids.length > 1 ? "s" : ""}: ${pids.join(", ")}) `
+                        + `but no PID file in data directory — not a running Flair instance. `
+                        + `Not killing — stop the process manually if it is not Flair.`);
+                    refusedKill = true;
+                }
+            }
+        }
+        catch { /* not running */ }
+        // Always remove per-user config on uninstall.
+        {
+            const cfgPath = configPath();
+            if (existsSync(cfgPath)) {
+                const { unlinkSync } = await import("node:fs");
+                unlinkSync(cfgPath);
+                console.log("✅ Config removed");
+            }
+        }
+        if (opts.purge) {
+            if (refusedKill) {
+                console.log("\n⚠️  Skipping purge: could not attribute the process on port — data preserved.");
+                console.log("Stop the process manually, then re-run: flair uninstall --purge");
+            }
+            else {
+                const home = process.env.HOME ?? homedir();
+                const result = purgeFlairInstall({ homeDir: home });
+                const report = formatPurgeReport(result);
+                console.log(report.lines.join("\n"));
+                if (purgeHadFailures(result))
+                    process.exit(1);
+            }
+        }
+        else {
+            console.log("\nData and keys preserved at ~/.flair/");
+            console.log("To remove everything: flair uninstall --purge");
+        }
+    });
+}