@tpsdev-ai/flair 0.3.19 → 0.4.0

package/README.md

@@ -88,6 +88,12 @@ flair agent add mybot --name "My Bot" --role assistant
 
 # Check everything is working
 flair status
+
+# Lifecycle management
+flair stop          # Stop the Flair instance
+flair restart       # Restart the Flair instance
+flair uninstall     # Remove the service (keeps data)
+flair uninstall --purge  # Remove everything including data and keys
 ```
 
 That's it. Your agent now has identity and memory.
@@ -163,7 +169,7 @@ npm install @tpsdev-ai/flair-client
 import { FlairClient } from '@tpsdev-ai/flair-client'
 
 const flair = new FlairClient({
-  url: 'http://localhost:9926',  // or remote: https://flair.example.com
+  url: 'http://localhost:19926',  // or remote: https://flair.example.com
   agentId: 'mybot',
   // key auto-resolved from ~/.flair/keys/mybot.key
 })
@@ -190,17 +196,17 @@ Flair is a pure HTTP API. Use it from Python, Go, Rust, shell scripts — anythi
 ```bash
 # Search memories
 curl -H "Authorization: TPS-Ed25519 mybot:$TS:$NONCE:$SIG" \
-  -X POST http://localhost:9926/SemanticSearch \
+  -X POST http://localhost:19926/SemanticSearch \
   -d '{"agentId": "mybot", "q": "deployment procedure", "limit": 5}'
 
 # Write a memory
 curl -H "Authorization: TPS-Ed25519 mybot:$TS:$NONCE:$SIG" \
-  -X PUT http://localhost:9926/Memory/mybot-123 \
+  -X PUT http://localhost:19926/Memory/mybot-123 \
   -d '{"id": "mybot-123", "agentId": "mybot", "content": "...", "durability": "standard"}'
 
 # Bootstrap (soul + recent memories)
 curl -H "Authorization: TPS-Ed25519 mybot:$TS:$NONCE:$SIG" \
-  -X POST http://localhost:9926/BootstrapMemories \
+  -X POST http://localhost:19926/BootstrapMemories \
   -d '{"agentId": "mybot", "maxTokens": 4000}'
 ```
 
@@ -245,15 +251,22 @@ flair init
 
 Your data stays on your machine. Best for personal agents, dev teams, and privacy-first setups. Flair runs as a single Harper process — no Docker, no cloud, no external services.
 
+#### Custom Ports
+If the default port (`19926`) is already in use, initialize with a custom port:
+```bash
+flair init --port 8000
+```
+Flair will automatically remember this port for future CLI commands by saving it to `~/.flair/config.yaml`.
+
 ### Remote Server
 
 Run Flair on a VPS or cloud instance. Agents connect over HTTPS:
 
 ```bash
 # On the server
-flair init --port 9926
+flair init --port 19926
 # Agents connect with:
-FLAIR_URL=https://your-server:9926 flair agent add mybot
+FLAIR_URL=https://your-server:19926 flair agent add mybot
 ```
 
 Good for teams with multiple machines or always-on agents.

package/config.yaml

@@ -1,8 +1,10 @@
 name: flair
 rest: true
 
-http:
-  port: 8787
+## Port is configured via CLI (flair init --port) or HTTP_PORT env var.
+## Omitted here to avoid conflicts with different deployment scenarios.
+# http:
+#   port: 19926
 
 graphqlSchema:
   files: schemas/*.graphql

package/dist/cli.js

@@ -7,8 +7,8 @@ import { join, resolve as resolvePath } from "node:path";
 import { spawn } from "node:child_process";
 import { createPrivateKey, sign as nodeCryptoSign, randomUUID } from "node:crypto";
 // ─── Defaults ────────────────────────────────────────────────────────────────
-const DEFAULT_PORT = 9926;
-const DEFAULT_OPS_PORT = 9925;
+const DEFAULT_PORT = 19926;
+const DEFAULT_OPS_PORT = 19925;
 const DEFAULT_ADMIN_USER = "admin";
 const STARTUP_TIMEOUT_MS = 60_000;
 const HEALTH_POLL_INTERVAL_MS = 500;
@@ -18,6 +18,27 @@ function defaultKeysDir() {
 function defaultDataDir() {
     return join(homedir(), ".flair", "data");
 }
+function configPath() {
+    return join(homedir(), ".flair", "config.yaml");
+}
+function readPortFromConfig() {
+    try {
+        const p = configPath();
+        if (existsSync(p)) {
+            const yaml = readFileSync(p, "utf-8");
+            const m = yaml.match(/port:\s*(\d+)/);
+            if (m)
+                return Number(m[1]);
+        }
+    }
+    catch { /* ignore */ }
+    return null;
+}
+function writeConfig(port) {
+    const p = configPath();
+    mkdirSync(join(homedir(), ".flair"), { recursive: true });
+    writeFileSync(p, `# Flair configuration\nport: ${port}\n`);
+}
 function privKeyPath(agentId, keysDir) {
     return join(keysDir, `${agentId}.key`);
 }
@@ -48,17 +69,8 @@ function b64url(bytes) {
 }
 async function api(method, path, body) {
     // Resolve port: FLAIR_URL env > ~/.flair/config.yaml > default 9926
-    let defaultUrl = "http://127.0.0.1:9926";
-    try {
-        const configPath = join(homedir(), ".flair", "config.yaml");
-        if (existsSync(configPath)) {
-            const yaml = readFileSync(configPath, "utf-8");
-            const portMatch = yaml.match(/port:\s*(\d+)/);
-            if (portMatch)
-                defaultUrl = `http://127.0.0.1:${portMatch[1]}`;
-        }
-    }
-    catch { /* ignore config read errors */ }
+    const savedPort = readPortFromConfig();
+    const defaultUrl = savedPort ? `http://127.0.0.1:${savedPort}` : `http://127.0.0.1:${DEFAULT_PORT}`;
     const base = process.env.FLAIR_URL || defaultUrl;
     // Auth resolution order:
     // 1. FLAIR_TOKEN env → Bearer token (backward compat)
@@ -261,9 +273,19 @@ program
             if (!bin)
                 throw new Error("@harperfast/harper not found in node_modules.\nRun: npm install @harperfast/harper");
             mkdirSync(dataDir, { recursive: true });
+            const opsSocket = join(dataDir, "operations-server");
+            const harperSetConfig = JSON.stringify({
+                rootPath: dataDir,
+                http: { port: httpPort, cors: true, corsAccessList: [`http://127.0.0.1:${httpPort}`, `http://localhost:${httpPort}`] },
+                operationsApi: { network: { port: opsPort, cors: true }, domainSocket: opsSocket },
+                mqtt: { network: { port: null }, webSocket: false },
+                localStudio: { enabled: false },
+                authentication: { authorizeLocal: true, enableSessions: true },
+            });
             const env = {
                 ...process.env,
                 ROOTPATH: dataDir,
+                HARPER_SET_CONFIG: harperSetConfig,
                 DEFAULTS_MODE: "dev",
                 HDB_ADMIN_USERNAME: adminUser,
                 HDB_ADMIN_PASSWORD: adminPass,
@@ -273,7 +295,10 @@ program
                 OPERATIONSAPI_NETWORK_PORT: String(opsPort),
                 LOCAL_STUDIO: "false",
             };
-            // Install
+            // Install Harper (creates system database, admin user, config file).
+            // IMPORTANT: Do NOT pre-create harper-config.yaml — Harper's install checks
+            // for its existence to detect existing installations. If found, it skips
+            // install and tries to read the (empty) database, causing a crash.
             console.log("Installing Harper...");
             await new Promise((resolve, reject) => {
                 let output = "";
@@ -282,17 +307,21 @@ program
                 install.stderr?.on("data", (d) => { output += d.toString(); });
                 install.on("exit", (code) => code === 0 ? resolve() : reject(new Error(`Harper install failed (${code}): ${output}`)));
                 install.on("error", reject);
-                setTimeout(() => { install.kill(); reject(new Error(`Harper install timed out: ${output}`)); }, 20_000);
+                setTimeout(() => { install.kill(); reject(new Error(`Harper install timed out: ${output}`)); }, 60_000);
             });
-            // Start (detached)
+            // Start Harper in dev mode (detached). Dev mode sets authorizeLocal=true
+            // which allows our Ed25519 middleware to handle auth while internal
+            // cross-resource calls (e.g. SemanticSearch → Memory) pass through.
             console.log(`Starting Harper on port ${httpPort}...`);
-            const proc = spawn(process.execPath, [bin, "run", "."], { cwd: flairPackageDir(), env, detached: true, stdio: "ignore" });
+            const proc = spawn(process.execPath, [bin, "dev", "."], { cwd: flairPackageDir(), env, detached: true, stdio: "ignore" });
             proc.unref();
         }
         console.log("Waiting for Harper health check...");
         await waitForHealth(httpPort, adminUser, adminPass, STARTUP_TIMEOUT_MS);
         console.log("Harper is healthy ✓");
     }
+    // Persist port to config so other commands can find this instance
+    writeConfig(httpPort);
     // Generate or reuse keypair
     mkdirSync(keysDir, { recursive: true });
     const privPath = privKeyPath(agentId, keysDir);
@@ -375,8 +404,10 @@ program
     }
     console.log(`\n   Claude Code: Add to your CLAUDE.md:`);
     console.log(`     At the start of every session, run mcp__flair__bootstrap before responding.`);
+    const mcpEnv = { FLAIR_AGENT_ID: agentId };
+    mcpEnv.FLAIR_URL = httpUrl;
     console.log(`\n   MCP config (.mcp.json):`);
-    console.log(`     { "mcpServers": { "flair": { "command": "npx", "args": ["@tpsdev-ai/flair-mcp"], "env": { "FLAIR_AGENT_ID": "${agentId}" } } } }`);
+    console.log(`     { "mcpServers": { "flair": { "command": "npx", "args": ["@tpsdev-ai/flair-mcp"], "env": ${JSON.stringify(mcpEnv)} } } }`);
 });
 // ─── flair agent ─────────────────────────────────────────────────────────────
 const agent = program.command("agent").description("Manage Flair agents");
@@ -714,10 +745,11 @@ program
 program
     .command("status")
     .description("Check Flair (Harper) instance health and agent count")
-    .option("--port <port>", "Harper HTTP port", String(DEFAULT_PORT))
+    .option("--port <port>", "Harper HTTP port")
     .option("--url <url>", "Flair base URL (overrides --port)")
     .action(async (opts) => {
-    const baseUrl = opts.url ?? `http://127.0.0.1:${opts.port}`;
+    const port = opts.port ? Number(opts.port) : (readPortFromConfig() ?? DEFAULT_PORT);
+    const baseUrl = opts.url ?? `http://127.0.0.1:${port}`;
     let healthy = false;
     let agentCount = null;
     let version = null;
@@ -788,6 +820,371 @@ program
     }
     console.log("\nTo upgrade: npm install -g @tpsdev-ai/flair@latest");
 });
+// ─── flair stop ───────────────────────────────────────────────────────────────
+program
+    .command("stop")
+    .description("Stop the running Flair (Harper) instance")
+    .option("--port <port>", "Harper HTTP port")
+    .action(async (opts) => {
+    const port = opts.port ? Number(opts.port) : (readPortFromConfig() ?? DEFAULT_PORT);
+    const platform = process.platform;
+    if (platform === "darwin") {
+        // macOS: try launchd first
+        const label = "ai.tpsdev.flair";
+        const plistPath = join(homedir(), "Library", "LaunchAgents", `${label}.plist`);
+        if (existsSync(plistPath)) {
+            try {
+                const { execSync } = await import("node:child_process");
+                execSync(`launchctl unload "${plistPath}"`, { stdio: "pipe" });
+                console.log("✅ Flair stopped (launchd service unloaded)");
+                return;
+            }
+            catch {
+                // launchd unload failed, try PID fallback
+            }
+        }
+    }
+    // Fallback: find process by port
+    try {
+        const { execSync } = await import("node:child_process");
+        const lsof = execSync(`lsof -ti :${port}`, { encoding: "utf-8" }).trim();
+        if (lsof) {
+            const pids = lsof.split("\n").map(p => p.trim()).filter(Boolean);
+            for (const pid of pids) {
+                process.kill(Number(pid), "SIGTERM");
+            }
+            console.log(`✅ Flair stopped (killed PID${pids.length > 1 ? "s" : ""}: ${pids.join(", ")})`);
+        }
+        else {
+            console.log("Flair is not running.");
+        }
+    }
+    catch {
+        console.log("Flair is not running (nothing found on port " + port + ").");
+    }
+});
+// ─── flair restart ────────────────────────────────────────────────────────────
+program
+    .command("restart")
+    .description("Restart the Flair (Harper) instance")
+    .option("--port <port>", "Harper HTTP port")
+    .action(async (opts) => {
+    const port = opts.port ? Number(opts.port) : (readPortFromConfig() ?? DEFAULT_PORT);
+    const platform = process.platform;
+    if (platform === "darwin") {
+        const label = "ai.tpsdev.flair";
+        const plistPath = join(homedir(), "Library", "LaunchAgents", `${label}.plist`);
+        if (existsSync(plistPath)) {
+            try {
+                const { execSync } = await import("node:child_process");
+                const uid = process.getuid?.() ?? 501;
+                execSync(`launchctl kickstart -k user/${uid}/${label}`, { stdio: "pipe" });
+                console.log("✅ Flair restarted (launchd kickstart)");
+                return;
+            }
+            catch (err) {
+                console.error(`launchd restart failed: ${err.message}`);
+            }
+        }
+        else {
+            console.error("❌ No launchd service found. Run 'flair init' first.");
+            process.exit(1);
+        }
+    }
+    else {
+        // Linux: stop + start via init
+        console.log("Stopping...");
+        try {
+            const { execSync } = await import("node:child_process");
+            const lsof = execSync(`lsof -ti :${port}`, { encoding: "utf-8" }).trim();
+            if (lsof) {
+                for (const pid of lsof.split("\n")) {
+                    try {
+                        process.kill(Number(pid.trim()), "SIGTERM");
+                    }
+                    catch { }
+                }
+                // Wait briefly for shutdown
+                await new Promise(r => setTimeout(r, 2000));
+            }
+        }
+        catch { /* not running */ }
+        console.log("Starting...");
+        const bin = harperBin();
+        if (!bin) {
+            console.error("❌ Harper binary not found. Run 'flair init' first.");
+            process.exit(1);
+        }
+        const dataDir = defaultDataDir();
+        const adminPass = process.env.HDB_ADMIN_PASSWORD ?? "";
+        const env = {
+            ...process.env,
+            ROOTPATH: dataDir,
+            DEFAULTS_MODE: "dev",
+            HDB_ADMIN_USERNAME: DEFAULT_ADMIN_USER,
+            HDB_ADMIN_PASSWORD: adminPass,
+            HTTP_PORT: String(port),
+            LOCAL_STUDIO: "false",
+        };
+        const proc = spawn(process.execPath, [bin, "run", "."], {
+            cwd: flairPackageDir(), env, detached: true, stdio: "ignore",
+        });
+        proc.unref();
+        try {
+            await waitForHealth(port, DEFAULT_ADMIN_USER, adminPass, STARTUP_TIMEOUT_MS);
+            console.log("✅ Flair restarted");
+        }
+        catch {
+            console.error("❌ Flair failed to restart within timeout");
+            process.exit(1);
+        }
+    }
+});
+// ─── flair uninstall ──────────────────────────────────────────────────────────
+program
+    .command("uninstall")
+    .description("Stop Flair and remove the launchd/systemd service")
+    .option("--purge", "Also remove data and keys (destructive)")
+    .action(async (opts) => {
+    const platform = process.platform;
+    const port = readPortFromConfig() ?? DEFAULT_PORT;
+    // Stop first
+    if (platform === "darwin") {
+        const label = "ai.tpsdev.flair";
+        const plistPath = join(homedir(), "Library", "LaunchAgents", `${label}.plist`);
+        if (existsSync(plistPath)) {
+            try {
+                const { execSync } = await import("node:child_process");
+                execSync(`launchctl unload "${plistPath}"`, { stdio: "pipe" });
+            }
+            catch { /* best effort */ }
+            const { unlinkSync } = await import("node:fs");
+            unlinkSync(plistPath);
+            console.log("✅ Launchd service removed");
+        }
+        else {
+            console.log("No launchd service found — skipping");
+        }
+    }
+    else {
+        // Linux: kill by port
+        try {
+            const { execSync } = await import("node:child_process");
+            const lsof = execSync(`lsof -ti :${port}`, { encoding: "utf-8" }).trim();
+            if (lsof) {
+                for (const pid of lsof.split("\n")) {
+                    try {
+                        process.kill(Number(pid.trim()), "SIGTERM");
+                    }
+                    catch { }
+                }
+            }
+        }
+        catch { /* not running */ }
+        console.log("✅ Flair process stopped");
+    }
+    // Remove config
+    const cfgPath = configPath();
+    if (existsSync(cfgPath)) {
+        const { unlinkSync } = await import("node:fs");
+        unlinkSync(cfgPath);
+        console.log("✅ Config removed");
+    }
+    if (opts.purge) {
+        const { rmSync } = await import("node:fs");
+        const dataDir = defaultDataDir();
+        const keysDir = defaultKeysDir();
+        const flairDir = join(homedir(), ".flair");
+        if (existsSync(dataDir)) {
+            rmSync(dataDir, { recursive: true, force: true });
+            console.log("✅ Data removed: " + dataDir);
+        }
+        if (existsSync(keysDir)) {
+            rmSync(keysDir, { recursive: true, force: true });
+            console.log("✅ Keys removed: " + keysDir);
+        }
+        // Remove .flair dir if empty
+        try {
+            const { readdirSync, rmdirSync } = await import("node:fs");
+            if (existsSync(flairDir) && readdirSync(flairDir).length === 0) {
+                rmdirSync(flairDir);
+            }
+        }
+        catch { /* non-empty, that's fine */ }
+        console.log("\n🗑️  Flair fully purged");
+    }
+    else {
+        console.log("\nData and keys preserved at ~/.flair/");
+        console.log("To remove everything: flair uninstall --purge");
+    }
+});
+// ─── flair reembed ────────────────────────────────────────────────────────────
+program
+    .command("reembed")
+    .description("Re-generate embeddings for memories with stale or missing model tags")
+    .requiredOption("--agent <id>", "Agent ID to re-embed memories for")
+    .option("--stale-only", "Only re-embed memories with mismatched model tag")
+    .option("--dry-run", "Show count without modifying")
+    .option("--port <port>", "Harper HTTP port")
+    .option("--batch-size <n>", "Records per batch", "50")
+    .option("--delay-ms <ms>", "Delay between batches (ms)", "100")
+    .action(async (opts) => {
+    const port = opts.port ? Number(opts.port) : (readPortFromConfig() ?? DEFAULT_PORT);
+    const baseUrl = `http://127.0.0.1:${port}`;
+    const agentId = opts.agent;
+    const staleOnly = opts.staleOnly ?? false;
+    const dryRun = opts.dryRun ?? false;
+    const batchSize = Number(opts.batchSize);
+    const delayMs = Number(opts.delayMs);
+    const currentModel = process.env.FLAIR_EMBEDDING_MODEL ?? "nomic-embed-text-v1.5-Q4_K_M";
+    console.log(`Re-embedding memories for agent: ${agentId}`);
+    console.log(`Current model: ${currentModel}`);
+    if (staleOnly)
+        console.log("Mode: stale-only (skipping up-to-date memories)");
+    if (dryRun)
+        console.log("Mode: dry-run (no modifications)");
+    console.log("");
+    const keysDir = defaultKeysDir();
+    const privPath = privKeyPath(agentId, keysDir);
+    if (!existsSync(privPath)) {
+        console.error(`❌ Key not found: ${privPath}`);
+        process.exit(1);
+    }
+    const searchRes = await authFetch(baseUrl, agentId, privPath, "POST", "/SemanticSearch", {
+        agentId, limit: 10000,
+    });
+    if (!searchRes.ok) {
+        console.error(`❌ Failed to fetch memories: ${searchRes.status}`);
+        process.exit(1);
+    }
+    const data = await searchRes.json();
+    const allMemories = data.results ?? [];
+    const candidates = allMemories.filter((m) => {
+        if (!m.content)
+            return false;
+        if (staleOnly)
+            return !m.embeddingModel || m.embeddingModel !== currentModel;
+        return true;
+    });
+    const total = candidates.length;
+    const skipped = allMemories.length - total;
+    console.log(`Total memories: ${allMemories.length}`);
+    console.log(`Candidates for re-embedding: ${total}`);
+    if (skipped > 0)
+        console.log(`Skipped (up-to-date): ${skipped}`);
+    if (dryRun || total === 0) {
+        if (total === 0)
+            console.log("\n✅ All memories are up-to-date!");
+        return;
+    }
+    console.log("");
+    let processed = 0;
+    let errors = 0;
+    for (let i = 0; i < candidates.length; i += batchSize) {
+        const batch = candidates.slice(i, i + batchSize);
+        for (const memory of batch) {
+            try {
+                const updateRes = await authFetch(baseUrl, agentId, privPath, "PUT", `/Memory/${memory.id}`, {
+                    id: memory.id, content: memory.content, embedding: undefined, embeddingModel: undefined,
+                });
+                if (updateRes.ok)
+                    processed++;
+                else
+                    errors++;
+            }
+            catch {
+                errors++;
+            }
+        }
+        const pct = Math.round(((i + batch.length) / total) * 100);
+        process.stdout.write(`\rRe-embedded ${processed}/${total} (${pct}%)${errors > 0 ? ` [${errors} errors]` : ""}`);
+        if (i + batchSize < candidates.length)
+            await new Promise(r => setTimeout(r, delayMs));
+    }
+    console.log(`\n\n✅ Re-embedding complete: ${processed} updated, ${errors} errors`);
+});
+// ─── flair test ───────────────────────────────────────────────────────────────
+program
+    .command("test")
+    .description("Verify Flair is working: store, search, bootstrap, cleanup")
+    .requiredOption("--agent <id>", "Agent ID to test with")
+    .option("--port <port>", "Harper HTTP port")
+    .action(async (opts) => {
+    const port = opts.port ? Number(opts.port) : (readPortFromConfig() ?? DEFAULT_PORT);
+    const baseUrl = `http://127.0.0.1:${port}`;
+    const agentId = opts.agent;
+    const keysDir = defaultKeysDir();
+    const privPath = privKeyPath(agentId, keysDir);
+    if (!existsSync(privPath)) {
+        console.error(`❌ Key not found: ${privPath}`);
+        console.error(`   Run: flair init --agent-id ${agentId}`);
+        process.exit(1);
+    }
+    const testId = `test-${agentId}-${Date.now()}`;
+    const testContent = `Flair test memory (${new Date().toISOString()})`;
+    let passed = 0;
+    let failed = 0;
+    const check = async (name, fn) => {
+        try {
+            const ok = await fn();
+            if (ok) {
+                console.log(`  ✅ ${name}`);
+                passed++;
+            }
+            else {
+                console.log(`  ❌ ${name}`);
+                failed++;
+            }
+        }
+        catch (e) {
+            console.log(`  ❌ ${name}: ${e.message?.slice(0, 100)}`);
+            failed++;
+        }
+    };
+    console.log(`\nFlair test (agent: ${agentId}, url: ${baseUrl})\n`);
+    // 1. Health
+    await check("Health check", async () => {
+        const res = await fetch(`${baseUrl}/Health`, { signal: AbortSignal.timeout(5000) });
+        return res.status > 0;
+    });
+    // 2. Store
+    await check("Memory store", async () => {
+        const res = await authFetch(baseUrl, agentId, privPath, "PUT", `/Memory/${testId}`, {
+            id: testId, agentId, content: testContent, durability: "ephemeral",
+            createdAt: new Date().toISOString(), archived: false,
+        });
+        return res.ok;
+    });
+    // 3. Search
+    await check("Semantic search", async () => {
+        await new Promise(r => setTimeout(r, 2000)); // wait for indexing
+        const res = await authFetch(baseUrl, agentId, privPath, "POST", "/SemanticSearch", {
+            agentId, q: "flair test memory", limit: 5,
+        });
+        if (!res.ok)
+            return false;
+        const data = await res.json();
+        return (data.results?.length ?? 0) > 0;
+    });
+    // 4. Bootstrap
+    await check("Bootstrap context", async () => {
+        const res = await authFetch(baseUrl, agentId, privPath, "POST", "/BootstrapMemories", {
+            agentId, maxTokens: 1000,
+        });
+        if (!res.ok)
+            return false;
+        const data = await res.json();
+        return (data.context?.length ?? 0) > 0;
+    });
+    // 5. Cleanup
+    await check("Memory delete", async () => {
+        const res = await authFetch(baseUrl, agentId, privPath, "DELETE", `/Memory/${testId}`);
+        return res.ok || res.status === 204;
+    });
+    console.log(`\n${passed} passed, ${failed} failed`);
+    if (failed > 0)
+        process.exit(1);
+});
 // ─── Legacy identity/memory/soul commands (preserved) ────────────────────────
 const identity = program.command("identity").description("Legacy identity commands");
 identity.command("register")

package/dist/resources/Memory.js

@@ -1,7 +1,9 @@
 import { databases } from "@harperfast/harper";
 import { patchRecord } from "./table-helpers.js";
 import { isAdmin } from "./auth-middleware.js";
-import { getEmbedding } from "./embeddings-provider.js";
+import { getEmbedding, getModelId } from "./embeddings-provider.js";
+import { scanContent, isStrictMode } from "./content-safety.js";
+import { checkRateLimit, rateLimitResponse } from "./rate-limiter.js";
 export class Memory extends databases.flair.Memory {
     /**
      * Override search() to scope collection GETs by authenticated agent.
@@ -55,6 +57,14 @@ export class Memory extends databases.flair.Memory {
         return super.search(conditions);
     }
     async post(content, context) {
+        // Rate limiting — use authenticated agent ID, not client-supplied body field
+        const ctx = this.getContext?.();
+        const authenticatedAgent = ctx?.request?.tpsAgent;
+        if (authenticatedAgent) {
+            const rl = checkRateLimit(authenticatedAgent, "general");
+            if (!rl.allowed)
+                return rateLimitResponse(rl.retryAfterMs, "write");
+        }
         content.durability ||= "standard";
         content.createdAt = new Date().toISOString();
         content.updatedAt = content.createdAt;
@@ -82,22 +92,61 @@ export class Memory extends databases.flair.Memory {
             const ttlHours = Number(process.env.FLAIR_EPHEMERAL_TTL_HOURS || 24);
             content.expiresAt = new Date(Date.now() + ttlHours * 3600_000).toISOString();
         }
+        // Content safety scan
+        if (content.content) {
+            const safety = scanContent(content.content);
+            if (!safety.safe) {
+                if (isStrictMode()) {
+                    return new Response(JSON.stringify({
+                        error: "content_safety_violation",
+                        flags: safety.flags,
+                        message: "Content flagged for potential prompt injection. Set FLAIR_CONTENT_SAFETY=warn to allow with tagging.",
+                    }), { status: 400, headers: { "Content-Type": "application/json" } });
+                }
+                content._safetyFlags = safety.flags;
+            }
+        }
         // Generate embedding from content text
         if (content.content && !content.embedding) {
             const vec = await getEmbedding(content.content);
-            if (vec)
+            if (vec) {
                 content.embedding = vec;
+                content.embeddingModel = getModelId();
+            }
         }
         return super.post(content);
     }
     async put(content) {
         const now = new Date().toISOString();
         content.updatedAt = now;
+        // Set defaults that post() sets — put() is also used for new records via CLI
+        content.archived = content.archived ?? false;
+        content.createdAt = content.createdAt ?? now;
+        // Content safety scan on updated content
+        if (content.content) {
+            const safety = scanContent(content.content);
+            if (!safety.safe) {
+                if (isStrictMode()) {
+                    return new Response(JSON.stringify({
+                        error: "content_safety_violation",
+                        flags: safety.flags,
+                        message: "Content flagged for potential prompt injection.",
+                    }), { status: 400, headers: { "Content-Type": "application/json" } });
+                }
+                content._safetyFlags = safety.flags;
+            }
+            else {
+                // Clear previous flags if content is now clean
+                content._safetyFlags = null;
+            }
+        }
         // Re-generate embedding if content changed
         if (content.content && !content.embedding) {
             const vec = await getEmbedding(content.content);
-            if (vec)
+            if (vec) {
                 content.embedding = vec;
+                content.embeddingModel = getModelId();
+            }
         }
         // If archiving, record who + when
         if (content.archived === true && !content.archivedAt) {