@tpsdev-ai/flair 0.5.3 → 0.6.0

package/dist/deploy.js

@@ -0,0 +1,161 @@
+import { spawn } from "node:child_process";
+import { dirname, join, resolve } from "node:path";
+import { existsSync, readFileSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import { createRequire } from "node:module";
+// Files that must be present in a Flair package for deployment.
+// Mirrors the `files` array in package.json — keep in sync.
+export const REQUIRED_PACKAGE_FILES = [
+    "dist",
+    "schemas",
+    "ui",
+    "config.yaml",
+];
+export function validateOptions(opts) {
+    const errors = [];
+    if (!opts.target) {
+        if (!opts.fabricOrg)
+            errors.push("--fabric-org required (or FABRIC_ORG env)");
+        if (!opts.fabricCluster)
+            errors.push("--fabric-cluster required (or FABRIC_CLUSTER env)");
+    }
+    const hasBasic = !!(opts.fabricUser && opts.fabricPassword);
+    const hasBearer = !!opts.fabricToken;
+    if (!hasBasic && !hasBearer) {
+        errors.push("credentials required: pass --fabric-user + --fabric-password " +
+            "(or FABRIC_USER / FABRIC_PASSWORD env), or --fabric-token " +
+            "(FABRIC_TOKEN env)");
+    }
+    return errors;
+}
+export function buildTargetUrl(opts) {
+    if (opts.target)
+        return opts.target;
+    return `https://${opts.fabricCluster}.${opts.fabricOrg}.harperfabric.com`;
+}
+export function resolvePackageRoot(override) {
+    if (override) {
+        const abs = resolve(override);
+        if (!existsSync(join(abs, "package.json"))) {
+            throw new Error(`No package.json at ${abs}`);
+        }
+        return abs;
+    }
+    // Walk up from this module's location — works when installed locally
+    // and when npx extracts the tarball to a tmpdir.
+    try {
+        const here = dirname(fileURLToPath(import.meta.url));
+        let dir = here;
+        for (let i = 0; i < 8; i++) {
+            const pkgPath = join(dir, "package.json");
+            if (existsSync(pkgPath)) {
+                const json = JSON.parse(readFileSync(pkgPath, "utf8"));
+                if (json.name === "@tpsdev-ai/flair")
+                    return dir;
+            }
+            const parent = dirname(dir);
+            if (parent === dir)
+                break;
+            dir = parent;
+        }
+    }
+    catch {
+        /* fall through */
+    }
+    try {
+        const req = createRequire(import.meta.url);
+        return dirname(req.resolve("@tpsdev-ai/flair/package.json"));
+    }
+    catch {
+        throw new Error("Could not locate @tpsdev-ai/flair package root. Try --package-root.");
+    }
+}
+export function validatePackageLayout(packageRoot) {
+    const missing = [];
+    for (const f of REQUIRED_PACKAGE_FILES) {
+        if (!existsSync(join(packageRoot, f)))
+            missing.push(f);
+    }
+    if (missing.length) {
+        throw new Error(`Flair package at ${packageRoot} is missing required entries: ` +
+            missing.join(", "));
+    }
+}
+function resolveHarperBin(packageRoot) {
+    const local = join(packageRoot, "node_modules/@harperfast/harper/dist/bin/harper.js");
+    if (existsSync(local))
+        return local;
+    try {
+        const req = createRequire(join(packageRoot, "package.json"));
+        const mainPath = req.resolve("@harperfast/harper");
+        let dir = dirname(mainPath);
+        for (let i = 0; i < 6; i++) {
+            const candidate = join(dir, "dist/bin/harper.js");
+            if (existsSync(candidate))
+                return candidate;
+            const parent = dirname(dir);
+            if (parent === dir)
+                break;
+            dir = parent;
+        }
+    }
+    catch {
+        /* fall through */
+    }
+    throw new Error("Could not locate Harper CLI binary (@harperfast/harper). " +
+        "Flair deploy requires Harper to be installed alongside Flair.");
+}
+function spawnHarper(bin, args, cwd, env) {
+    return new Promise((resolveP, rejectP) => {
+        const p = spawn(process.execPath, [bin, ...args], {
+            cwd,
+            stdio: "inherit",
+            env,
+        });
+        p.on("error", rejectP);
+        p.on("exit", (code) => {
+            if (code === 0)
+                resolveP();
+            else
+                rejectP(new Error(`harper deploy exited with code ${code}`));
+        });
+    });
+}
+export async function deploy(opts) {
+    const errors = validateOptions(opts);
+    if (errors.length) {
+        throw new Error(errors.join("\n"));
+    }
+    const packageRoot = resolvePackageRoot(opts.packageRoot);
+    validatePackageLayout(packageRoot);
+    const pkg = JSON.parse(readFileSync(join(packageRoot, "package.json"), "utf8"));
+    const version = opts.version ?? pkg.version;
+    const project = opts.project ?? "flair";
+    const url = buildTargetUrl(opts);
+    if (opts.dryRun) {
+        return { url, project, version, packageRoot, dryRun: true };
+    }
+    if (opts.fabricToken && !(opts.fabricUser && opts.fabricPassword)) {
+        throw new Error("Bearer token auth (--fabric-token) is not yet supported — " +
+            "Harper's deploy_component CLI path only accepts Basic auth today. " +
+            "Pass --fabric-user + --fabric-password instead.");
+    }
+    const harperBin = resolveHarperBin(packageRoot);
+    const args = [
+        "deploy",
+        `target=${url}`,
+        `project=${project}`,
+        `restart=${opts.restart !== false}`,
+        `replicated=${opts.replicated !== false}`,
+    ];
+    // Credentials go via env, not argv, so they don't appear in `ps` output
+    // for the lifetime of the Harper child process. Harper's cliOperations
+    // reads CLI_TARGET_USERNAME / CLI_TARGET_PASSWORD as env fallbacks.
+    const childEnv = {
+        ...process.env,
+        CLI_TARGET_USERNAME: opts.fabricUser,
+        CLI_TARGET_PASSWORD: opts.fabricPassword,
+    };
+    await spawnHarper(harperBin, args, packageRoot, childEnv);
+    return { url, project, version, packageRoot, dryRun: false };
+}

package/dist/resources/MemoryBootstrap.js

@@ -41,24 +41,34 @@ function formatMemory(m, supersedes) {
 }
 export class BootstrapMemories extends Resource {
     async post(data, _context) {
-        const { agentId, currentTask, maxTokens = 4000, includeSoul = true, since, channel, // e.g., "discord", "tps-mail", "claude-code"
+        const { agentId: bodyAgentId, currentTask, maxTokens = 4000, includeSoul = true, since, channel, // e.g., "discord", "tps-mail", "claude-code"
         surface, // e.g., "tps-build", "tps-review", "cli-session"
         subjects, // e.g., ["flair", "auth"] — entities to preload context for
          } = data || {};
-        if (!agentId) {
+        // Authenticated identity lives on getContext().request — `this.request` is
+        // NOT populated on Harper v5 Resources. Reading it returned undefined and
+        // the scope check was silently bypassed, letting a non-admin agent read
+        // another agent's soul + memories by passing the victim's id in the body.
+        const ctx = this.getContext?.();
+        const request = ctx?.request ?? ctx;
+        const authenticatedAgent = request?.tpsAgent ?? request?.headers?.get?.("x-tps-agent");
+        const callerIsAdmin = request?.tpsAgentIsAdmin === true;
+        if (!bodyAgentId && !authenticatedAgent) {
             return new Response(JSON.stringify({ error: "agentId required" }), {
                 status: 400,
                 headers: { "Content-Type": "application/json" },
             });
         }
-        // Defense-in-depth: agentId must match authenticated agent
-        const authenticatedAgent = this.request?.headers?.get?.("x-tps-agent");
-        const callerIsAdmin = this.request?.tpsAgentIsAdmin === true;
-        if (authenticatedAgent && !callerIsAdmin && agentId !== authenticatedAgent) {
+        if (authenticatedAgent && !callerIsAdmin && bodyAgentId && bodyAgentId !== authenticatedAgent) {
             return new Response(JSON.stringify({
                 error: "forbidden: agentId must match authenticated agent",
             }), { status: 403, headers: { "Content-Type": "application/json" } });
         }
+        // Pin scope to the authenticated agent for non-admins; admins can bootstrap
+        // any agentId (needed for setup scripts and UI impersonation flows).
+        const agentId = (authenticatedAgent && !callerIsAdmin)
+            ? authenticatedAgent
+            : bodyAgentId;
         const sections = {
             soul: [],
             skills: [],

package/dist/resources/MemoryConsolidate.js

@@ -57,13 +57,22 @@ function evaluate(record, now, olderThanMs) {
 }
 export class ConsolidateMemories extends Resource {
     async post(data) {
-        const { agentId, scope = "persistent", olderThan = "30d", limit = 20 } = data || {};
-        if (!agentId)
+        const { agentId: bodyAgentId, scope = "persistent", olderThan = "30d", limit = 20 } = data || {};
+        // See SemanticSearch / MemoryBootstrap — `this.request` isn't populated on
+        // Harper v5 Resources, so the prior actorId check was silently bypassed
+        // and bob could enumerate alice's consolidation candidates (her memory records).
+        const ctx = this.getContext?.();
+        const request = ctx?.request ?? ctx;
+        const actorId = request?.tpsAgent;
+        const callerIsAdmin = request?.tpsAgentIsAdmin === true
+            || (actorId ? await isAdmin(actorId) : false);
+        if (!bodyAgentId && !actorId) {
             return new Response(JSON.stringify({ error: "agentId required" }), { status: 400 });
-        const actorId = this.request?.tpsAgent;
-        if (actorId && actorId !== agentId && !(await isAdmin(actorId))) {
+        }
+        if (actorId && !callerIsAdmin && bodyAgentId && bodyAgentId !== actorId) {
             return new Response(JSON.stringify({ error: "forbidden: can only consolidate own memories" }), { status: 403 });
         }
+        const agentId = (actorId && !callerIsAdmin) ? actorId : bodyAgentId;
         const olderThanMs = parseDuration(olderThan);
         const now = Date.now();
         const candidates = [];

package/dist/resources/MemoryReflect.js

@@ -30,14 +30,23 @@ const FOCUS_PROMPTS = {
 };
 export class ReflectMemories extends Resource {
     async post(data) {
-        const { agentId, scope = "recent", since, maxMemories = 50, focus = "lessons_learned", tag, } = data || {};
-        if (!agentId)
+        const { agentId: bodyAgentId, scope = "recent", since, maxMemories = 50, focus = "lessons_learned", tag, } = data || {};
+        // Authenticated identity comes from getContext().request, not this.request
+        // (see SemanticSearch / MemoryBootstrap for the same bug class). The prior
+        // check was silently bypassed — bob could reflect on alice's memories and
+        // mutate alice's records via the lastReflected patchRecordSilent below.
+        const ctx = this.getContext?.();
+        const request = ctx?.request ?? ctx;
+        const actorId = request?.tpsAgent;
+        const callerIsAdmin = request?.tpsAgentIsAdmin === true
+            || (actorId ? await isAdmin(actorId) : false);
+        if (!bodyAgentId && !actorId) {
             return new Response(JSON.stringify({ error: "agentId required" }), { status: 400 });
-        // Auth: agent can only reflect on own memories unless admin
-        const actorId = this.request?.tpsAgent;
-        if (actorId && actorId !== agentId && !(await isAdmin(actorId))) {
+        }
+        if (actorId && !callerIsAdmin && bodyAgentId && bodyAgentId !== actorId) {
             return new Response(JSON.stringify({ error: "forbidden: can only reflect on own memories" }), { status: 403 });
         }
+        const agentId = (actorId && !callerIsAdmin) ? actorId : bodyAgentId;
         const sinceDate = since ? new Date(since) : new Date(Date.now() - 24 * 3600_000);
         const memories = [];
         for await (const record of databases.flair.Memory.search()) {

package/dist/resources/ObservationCenter.js

@@ -0,0 +1,19 @@
+import { Resource } from "@harperfast/harper";
+import { readFileSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import { dirname, resolve } from "node:path";
+const HERE = dirname(fileURLToPath(import.meta.url));
+const HTML_PATH = resolve(HERE, "..", "..", "ui", "observation-center.html");
+const HTML = readFileSync(HTML_PATH, "utf8");
+/**
+ * GET /ObservationCenter — serves the read-only dashboard shell.
+ * The HTML handles its own Basic-auth prompt and polls authenticated JSON endpoints.
+ */
+export class ObservationCenter extends Resource {
+    async get() {
+        return new Response(HTML, {
+            status: 200,
+            headers: { "content-type": "text/html; charset=utf-8" },
+        });
+    }
+}

package/dist/resources/SemanticSearch.js

@@ -46,13 +46,20 @@ function distanceToSimilarity(distance) {
 const CANDIDATE_MULTIPLIER = 5;
 export class SemanticSearch extends Resource {
     async post(data) {
-        const { agentId, q, queryEmbedding, tag, subject, subjects, limit = 10, includeSuperseded = false, scoring = "composite", minScore = 0, since, asOf } = data || {};
-        // Rate limiting — use authenticated agent ID from request context, not client-supplied body
-        const rateLimitAgent = this.request?.headers?.get?.("x-tps-agent")
-            ?? this.request?.tpsAgent;
-        if (rateLimitAgent) {
+        const { agentId: bodyAgentId, q, queryEmbedding, tag, subject, subjects, limit = 10, includeSuperseded = false, scoring = "composite", minScore = 0, since, asOf } = data || {};
+        // Authenticated identity lives on the Harper Resource context (getContext().request).
+        // `this.request` is NOT populated on Harper v5 Resources — prior reads here
+        // silently returned undefined and the defense-in-depth scope check below
+        // was bypassed, letting a non-admin agent read another agent's memories
+        // by putting the victim's id in the body.
+        const ctx = this.getContext?.();
+        const request = ctx?.request ?? ctx;
+        const authenticatedAgent = request?.tpsAgent ?? request?.headers?.get?.("x-tps-agent");
+        const callerIsAdmin = request?.tpsAgentIsAdmin === true;
+        // Rate limiting — use authenticated agent ID, not client-supplied body
+        if (authenticatedAgent) {
             const bucket = q && !queryEmbedding ? "embedding" : "general";
-            const rl = checkRateLimit(rateLimitAgent, bucket);
+            const rl = checkRateLimit(authenticatedAgent, bucket);
             if (!rl.allowed)
                 return rateLimitResponse(rl.retryAfterMs, "search");
         }
@@ -61,15 +68,19 @@ export class SemanticSearch extends Resource {
             : subject
                 ? new Set([subject.toLowerCase()])
                 : null;
-        // Defense-in-depth: verify agentId matches authenticated agent.
-        const authenticatedAgent = this.request?.headers?.get?.("x-tps-agent");
-        const callerIsAdmin = this.request?.tpsAgentIsAdmin === true;
-        if (authenticatedAgent && !callerIsAdmin && agentId && agentId !== authenticatedAgent) {
+        // Enforce agentId = authenticated agent for non-admins. A mismatched body
+        // agentId is a cross-agent read attempt — reject outright. Admins can query
+        // any agentId (needed for bootstrap / consolidation scripts).
+        if (authenticatedAgent && !callerIsAdmin && bodyAgentId && bodyAgentId !== authenticatedAgent) {
             return new Response(JSON.stringify({
                 error: "forbidden: agentId must match authenticated agent",
             }), { status: 403, headers: { "Content-Type": "application/json" } });
         }
-        // Determine searchable agent IDs (own + granted)
+        // Scope search to the authenticated agent (own + granted). For admins or
+        // unauthenticated internal calls, honor the body-supplied agentId.
+        const agentId = (authenticatedAgent && !callerIsAdmin)
+            ? authenticatedAgent
+            : bodyAgentId;
         const searchAgentIds = new Set();
         if (agentId)
             searchAgentIds.add(agentId);

package/dist/resources/auth-middleware.js

@@ -150,6 +150,12 @@ server.http(async (request, nextLayer) => {
                 request.headers.set("x-tps-agent", "admin");
                 if (request.headers.asObject)
                     request.headers.asObject["x-tps-agent"] = "admin";
+                // Basic admin auth IS admin — resource-level checks (SemanticSearch,
+                // MemoryBootstrap, MemoryReflect, MemoryConsolidate) gate cross-agent
+                // access on this flag. Prior to 0.5.5 the check was a no-op so this
+                // was never needed; now it must be set.
+                request.tpsAgent = "admin";
+                request.tpsAgentIsAdmin = true;
                 return nextLayer(request);
             }
         }