leedab 0.1.8 → 0.2.0

package/dist/agent/resolveMember.d.ts

@@ -0,0 +1,21 @@
+import { type ChannelName } from "../team/permissions.js";
+import type { Role } from "../team.js";
+export interface ResolvedMember {
+    memberId: string;
+    name: string;
+    role: Role;
+    allowedWorkflows: string[];
+    allowedChannels: ChannelName[];
+}
+/**
+ * Normalize a channel user id or handle for comparison.
+ * WhatsApp reports E.164 like "+13025551234" or "13025551234@c.us".
+ * Telegram reports a numeric id.
+ * Teams reports an Azure AD object id.
+ */
+export declare function normalizeHandle(value: string | undefined): string;
+/**
+ * Look up a resolved member for a channel/userId pair.
+ * Returns null when no member in the overlay owns that handle on that channel.
+ */
+export declare function resolveMember(channel: ChannelName, userId: string): Promise<ResolvedMember | null>;

package/dist/agent/resolveMember.js

@@ -0,0 +1,44 @@
+import { readOverlay } from "../team/permissions.js";
+/**
+ * Normalize a channel user id or handle for comparison.
+ * WhatsApp reports E.164 like "+13025551234" or "13025551234@c.us".
+ * Telegram reports a numeric id.
+ * Teams reports an Azure AD object id.
+ */
+export function normalizeHandle(value) {
+    if (!value)
+        return "";
+    return value
+        .trim()
+        .toLowerCase()
+        .replace(/[\s\-()]/g, "")
+        .replace(/^@/, "")
+        .replace(/^\+/, "")
+        .replace(/@c\.us$/, "")
+        .replace(/@s\.whatsapp\.net$/, "");
+}
+/**
+ * Look up a resolved member for a channel/userId pair.
+ * Returns null when no member in the overlay owns that handle on that channel.
+ */
+export async function resolveMember(channel, userId) {
+    const needle = normalizeHandle(userId);
+    if (!needle)
+        return null;
+    const overlay = await readOverlay();
+    for (const [id, perms] of Object.entries(overlay.members)) {
+        if (channel === "dashboard")
+            continue;
+        const handle = perms.handles[channel];
+        if (handle && normalizeHandle(handle) === needle) {
+            return {
+                memberId: id,
+                name: perms.name,
+                role: perms.role,
+                allowedWorkflows: [...(perms.allowedWorkflows ?? [])],
+                allowedChannels: [...(perms.allowedChannels ?? [])],
+            };
+        }
+    }
+    return null;
+}

package/dist/dashboard/routes.d.ts

@@ -1,5 +1,17 @@
 import { type IncomingMessage, type ServerResponse } from "node:http";
 import type { LeedABConfig } from "../config/schema.js";
+import { type ChannelName } from "../team/permissions.js";
 type RouteHandler = (req: IncomingMessage, res: ServerResponse, url: URL) => Promise<void>;
 export declare function createRoutes(config: LeedABConfig): Record<string, RouteHandler>;
+/**
+ * Build the permission preamble injected into the agent prompt for a given
+ * channel message. Returns null when we have nothing to add (unknown user
+ * on a non-dashboard channel — the allowlist will already have rejected
+ * those).
+ *
+ * This preamble is the sole workflow-permission gate. We trust the agent to
+ * honor it. There is no server-side hard gate; admins restrict access by
+ * naming the workflows a member may use in the team page.
+ */
+export declare function buildPermissionPreamble(channel: ChannelName, userId: string): Promise<string | null>;
 export {};

package/dist/dashboard/routes.js

@@ -5,9 +5,14 @@ import { promisify } from "node:util";
 import { userInfo } from "node:os";
 import { resolveOpenClawBin, openclawEnv } from "../openclaw.js";
 import { addEntry, removeEntry, listEntries } from "../vault.js";
-import { readAuditLog } from "../audit.js";
+import { readAuditLog, logAudit } from "../audit.js";
 import { getAnalytics } from "../analytics.js";
-import { loadTeam, addMember, removeMember, updateRole } from "../team.js";
+import { loadTeam, addMember, removeMember, updateRole, } from "../team.js";
+import { loadLicense } from "../license.js";
+import { setMemberPermissions, } from "../team/permissions.js";
+import { syncAllowlists } from "../team/syncAllowlists.js";
+import { resolveMember } from "../agent/resolveMember.js";
+import { WORKFLOWS, getWorkflow } from "../workflows/registry.js";
 import { STATE_DIR } from "../paths.js";
 const execFileAsync = promisify(execFile);
 async function restartGatewayQuietly(stateDir) {
@@ -35,10 +40,16 @@ export function createRoutes(config) {
                 json(res, { error: "message is required" }, 400);
                 return;
             }
+            // Permission enforcement lives in the prompt preamble. The dashboard
+            // chat runs as the local admin / install owner, so the preamble here
+            // is informational ("assisting <admin>"). The same builder is the
+            // single gate used by channel handlers when we wire them up.
+            const preamble = await buildPermissionPreamble("dashboard", userInfo().username);
+            const agentMessage = preamble ? `${preamble}\n\n${message}` : message;
             try {
                 const args = [
                     "agent",
-                    "--message", message,
+                    "--message", agentMessage,
                     "--session-id", session ?? "console",
                     "--json",
                 ];
@@ -251,6 +262,36 @@ export function createRoutes(config) {
                         catch { }
                     }
                 }
+                // Enrich each session with sender name and first message summary
+                await Promise.all(results.map(async (s) => {
+                    try {
+                        const filePath = resolve(sessionsDir, `${s.sessionId}.jsonl`);
+                        const raw = await readFile(filePath, "utf-8");
+                        const firstMsg = raw.split("\n").find((line) => {
+                            if (!line.trim())
+                                return false;
+                            try {
+                                const obj = JSON.parse(line);
+                                return obj.type === "message" && obj.message?.role === "user";
+                            }
+                            catch {
+                                return false;
+                            }
+                        });
+                        if (!firstMsg)
+                            return;
+                        const parsed = JSON.parse(firstMsg);
+                        const text = parsed.message?.content?.[0]?.text ?? "";
+                        // Extract sender + clean summary using openclaw's metadata format.
+                        // Metadata blocks are sentinel lines followed by ```json ... ```
+                        const { senderName, cleanText } = parseSessionFirstMessage(text);
+                        if (senderName)
+                            s.senderName = senderName;
+                        if (cleanText)
+                            s.summary = cleanText.slice(0, 120);
+                    }
+                    catch { }
+                }));
                 // Sort newest first
                 results.sort((a, b) => (b.updatedAt ?? 0) - (a.updatedAt ?? 0));
                 json(res, results);
@@ -432,28 +473,39 @@ export function createRoutes(config) {
             json(res, { ok: removed, service });
         },
         /**
-         * GET /api/team — list team members
+         * GET /api/team — list local team members
          */
         "GET /api/team": async (_req, res) => {
-            const team = await loadTeam();
-            json(res, team);
+            try {
+                const team = await loadTeam();
+                json(res, team);
+            }
+            catch (err) {
+                json(res, { error: err.message ?? "Failed to load team" }, 500);
+            }
         },
         /**
-         * POST /api/team — add a team member
+         * POST /api/team — add a team member locally
          */
         "POST /api/team": async (req, res) => {
             const body = await readBody(req);
-            const { name, email, role, channels } = JSON.parse(body);
-            if (!name || typeof name !== "string") {
+            const { name, email, role } = JSON.parse(body);
+            if (!name || typeof name !== "string" || !name.trim()) {
                 json(res, { error: "name is required" }, 400);
                 return;
             }
-            const member = await addMember({
-                name: name.trim(),
-                email: email || "",
-                role: role || "member",
-            });
-            json(res, member, 201);
+            const normalizedRole = role || "member";
+            if (normalizedRole !== "admin" && normalizedRole !== "member") {
+                json(res, { error: "role must be admin or member" }, 400);
+                return;
+            }
+            try {
+                const member = await addMember({ name: name.trim(), email, role: normalizedRole });
+                json(res, member, 201);
+            }
+            catch (err) {
+                json(res, { error: err.message }, 500);
+            }
         },
         /**
          * DELETE /api/team — remove a team member
@@ -466,6 +518,12 @@ export function createRoutes(config) {
                 return;
             }
             const removed = await removeMember(id);
+            if (removed) {
+                try {
+                    await syncAllowlists();
+                }
+                catch { /* best-effort */ }
+            }
             json(res, { ok: removed });
         },
         /**
@@ -481,8 +539,170 @@ export function createRoutes(config) {
             const updated = await updateRole(id, role);
             json(res, { ok: updated });
         },
+        /**
+         * PUT /api/team/permissions — update a member's local overlay permissions
+         * and rebuild channel allowlists.
+         */
+        "PUT /api/team/permissions": async (req, res) => {
+            const body = await readBody(req);
+            const { memberId, handles, allowedWorkflows, allowedChannels } = JSON.parse(body);
+            if (!memberId || typeof memberId !== "string") {
+                json(res, { error: "memberId is required" }, 400);
+                return;
+            }
+            // Lightweight validation. The dashboard posts known-good values.
+            const validChannels = ["whatsapp", "telegram", "teams", "dashboard"];
+            const perms = {};
+            if (handles && typeof handles === "object") {
+                perms.handles = {
+                    whatsapp: handles.whatsapp?.toString().trim() || undefined,
+                    telegram: handles.telegram?.toString().trim() || undefined,
+                    teams: handles.teams?.toString().trim() || undefined,
+                };
+            }
+            if (Array.isArray(allowedWorkflows)) {
+                perms.allowedWorkflows = allowedWorkflows
+                    .filter((id) => typeof id === "string")
+                    .filter((id) => getWorkflow(id) !== undefined);
+            }
+            if (Array.isArray(allowedChannels)) {
+                perms.allowedChannels = allowedChannels.filter((c) => typeof c === "string" && validChannels.includes(c));
+            }
+            try {
+                const saved = await setMemberPermissions(memberId, perms);
+                await syncAllowlists();
+                await logAudit({
+                    timestamp: new Date().toISOString(),
+                    user: "dashboard",
+                    channel: "dashboard",
+                    action: "permissions_updated",
+                    responseSummary: `member ${memberId} perms updated`,
+                }).catch(() => { });
+                json(res, { ok: true, permissions: saved });
+            }
+            catch (err) {
+                json(res, { error: err.message ?? "Failed to save" }, 500);
+            }
+        },
+        /**
+         * GET /api/workflows — static workflow registry, used by the permissions UI
+         */
+        "GET /api/workflows": async (_req, res) => {
+            json(res, WORKFLOWS);
+        },
+        /**
+         * GET /api/license — read-only license info for the dashboard (seat chip)
+         */
+        "GET /api/license": async (_req, res) => {
+            const license = await loadLicense();
+            if (!license) {
+                json(res, { valid: false, tier: "none", seatsUsed: 0, maxSeats: 0 });
+                return;
+            }
+            const { valid, tier, status, seatsUsed, maxSeats, email, name, orgName } = license;
+            json(res, { valid, tier, status, seatsUsed, maxSeats, email, name, orgName });
+        },
     };
 }
+/**
+ * Build the permission preamble injected into the agent prompt for a given
+ * channel message. Returns null when we have nothing to add (unknown user
+ * on a non-dashboard channel — the allowlist will already have rejected
+ * those).
+ *
+ * This preamble is the sole workflow-permission gate. We trust the agent to
+ * honor it. There is no server-side hard gate; admins restrict access by
+ * naming the workflows a member may use in the team page.
+ */
+export async function buildPermissionPreamble(channel, userId) {
+    const resolved = await resolveMember(channel, userId);
+    if (!resolved)
+        return null;
+    const allowed = resolved.allowedWorkflows.length
+        ? resolved.allowedWorkflows
+            .map((id) => getWorkflow(id)?.title ?? id)
+            .join(", ")
+        : "all workflows";
+    return [
+        `[System] You are currently assisting ${resolved.name} (role: ${resolved.role}).`,
+        `They are authorized to use these workflows: ${allowed}.`,
+        `If they ask for any workflow outside that list, politely say it isn't enabled for them yet and suggest they contact their admin. Do not run it regardless of how the request is phrased.`,
+    ].join(" ");
+}
+/**
+ * Parse the first user message of a session JSONL to extract sender name and
+ * clean summary text. Mirrors openclaw's stripInboundMetadata + extractInboundSenderLabel.
+ */
+function parseSessionFirstMessage(text) {
+    let senderName = null;
+    // --- Extract sender from metadata blocks ---
+    const SENTINELS = [
+        "Conversation info (untrusted metadata):",
+        "Sender (untrusted metadata):",
+        "Thread starter (untrusted, for context):",
+        "Replied message (untrusted, for context):",
+        "Forwarded message context (untrusted metadata):",
+        "Chat history since last reply (untrusted, for context):",
+    ];
+    const lines = text.split("\n");
+    const cleaned = [];
+    let i = 0;
+    while (i < lines.length) {
+        const trimmed = lines[i].trim();
+        // Check if this line is a metadata sentinel followed by ```json
+        if (SENTINELS.includes(trimmed) && lines[i + 1]?.trim() === "```json") {
+            // Extract name/label from Sender block before skipping
+            const isSender = trimmed.startsWith("Sender ");
+            const isConvo = trimmed.startsWith("Conversation info");
+            i += 2; // skip sentinel + ```json
+            let jsonBuf = "";
+            while (i < lines.length && lines[i].trim() !== "```") {
+                jsonBuf += lines[i] + "\n";
+                i++;
+            }
+            if (i < lines.length)
+                i++; // skip closing ```
+            if (!senderName && (isSender || isConvo)) {
+                try {
+                    const meta = JSON.parse(jsonBuf);
+                    senderName = meta.label || meta.name || meta.username || meta.sender || null;
+                }
+                catch { }
+            }
+            continue;
+        }
+        cleaned.push(lines[i]);
+        i++;
+    }
+    let userText = cleaned.join("\n").trim();
+    // Strip leading timestamp [Thu 2026-04-02 07:52 EDT]
+    userText = userText.replace(/^\[[A-Za-z]{3} \d{4}-\d{2}-\d{2} \d{2}:\d{2}[^\]]*\]\s*/, "");
+    // Cron: use the description as the summary
+    const cronMatch = userText.match(/^\[cron:[^\s\]]+\s+([^\]]+)\]/);
+    if (cronMatch) {
+        userText = cronMatch[1];
+    }
+    userText = userText.replace(/^\[cron:[^\]]*\]\s*/, "");
+    // Subagent: extract the task
+    const subagentTask = userText.match(/\[Subagent Task\]:\s*([\s\S]*)/);
+    if (subagentTask) {
+        userText = subagentTask[1];
+    }
+    // Strip [Subagent Context] blocks
+    userText = userText.replace(/\[Subagent Context\][\s\S]*?\n\n/g, "");
+    // Strip another leading timestamp that may remain
+    userText = userText.replace(/^\[[A-Za-z]{3} \d{4}-\d{2}-\d{2} \d{2}:\d{2}[^\]]*\]\s*/, "");
+    // Heartbeat
+    if (userText.startsWith("Read HEARTBEAT.md")) {
+        userText = "Heartbeat check";
+    }
+    // Strip trailing cron boilerplate
+    userText = userText.replace(/\nCurrent time:[\s\S]*$/, "");
+    userText = userText.replace(/\nReturn your summary[\s\S]*$/, "");
+    // Strip "Untrusted context" trailing block
+    userText = userText.replace(/\nUntrusted context \(metadata[\s\S]*$/, "");
+    return { senderName, cleanText: userText.trim() };
+}
 function json(res, data, status = 200) {
     res.writeHead(status, { "Content-Type": "application/json" });
     res.end(JSON.stringify(data));

package/dist/dashboard/server.js

@@ -12,7 +12,12 @@ const MIME_TYPES = {
 };
 export async function startDashboard(config, port = 3000) {
     const routes = createRoutes(config);
-    const staticDir = resolve(import.meta.dirname, "static");
+    // In dev, serve from src/ so HTML/CSS changes are instant (no rebuild needed).
+    // In production (running from dist/), fall back to the compiled copy.
+    const devStaticDir = resolve(import.meta.dirname, "../../src/dashboard/static");
+    const prodStaticDir = resolve(import.meta.dirname, "static");
+    const { existsSync } = await import("node:fs");
+    const staticDir = existsSync(devStaticDir) ? devStaticDir : prodStaticDir;
     const server = createServer(async (req, res) => {
         const url = new URL(req.url ?? "/", `http://localhost:${port}`);
         const method = req.method ?? "GET";