@agents-tower/core 0.1.0

package/dist/openclaw.js

@@ -0,0 +1,715 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.openClawSessionToActivityState = openClawSessionToActivityState;
+exports.openClawSessionDetail = openClawSessionDetail;
+exports.openClawWorkspaceMatchesProject = openClawWorkspaceMatchesProject;
+exports.discoverOpenClawProjects = discoverOpenClawProjects;
+exports.loadOpenClawAgents = loadOpenClawAgents;
+exports.loadRoamingOpenClawSnapshotData = loadRoamingOpenClawSnapshotData;
+exports.openClawSessionWorkspaceLabel = openClawSessionWorkspaceLabel;
+const node_crypto_1 = require("node:crypto");
+const node_path_1 = require("node:path");
+const appearance_1 = require("./appearance");
+const project_paths_1 = require("./project-paths");
+const DEFAULT_OPENCLAW_GATEWAY_URL = "ws://127.0.0.1:18789";
+const OPENCLAW_REQUEST_TIMEOUT_MS = 4000;
+const OPENCLAW_CONNECT_TIMEOUT_MS = 2500;
+const OPENCLAW_CACHE_TTL_MS = 5000;
+const OPENCLAW_DISCOVERY_WINDOW_MS = 24 * 60 * 60 * 1000;
+const OPENCLAW_PROTOCOL_VERSION = 1;
+let cachedWorkspaceData = null;
+let cachedWorkspaceDataAt = 0;
+let cachedIdentity = null;
+function openClawEnabled() {
+    return [
+        process.env.OPENCLAW_GATEWAY_URL,
+        process.env.OPENCLAW_GATEWAY_TOKEN,
+        process.env.OPENCLAW_GATEWAY_PASSWORD
+    ].some((value) => typeof value === "string" && value.trim().length > 0);
+}
+function openClawGatewayUrl() {
+    const configured = process.env.OPENCLAW_GATEWAY_URL;
+    if (typeof configured !== "string" || configured.trim().length === 0) {
+        return DEFAULT_OPENCLAW_GATEWAY_URL;
+    }
+    return configured.trim();
+}
+function openClawGatewayToken() {
+    const configured = process.env.OPENCLAW_GATEWAY_TOKEN;
+    if (typeof configured !== "string") {
+        return undefined;
+    }
+    const trimmed = configured.trim();
+    return trimmed.length > 0 ? trimmed : undefined;
+}
+function openClawGatewayPassword() {
+    const configured = process.env.OPENCLAW_GATEWAY_PASSWORD;
+    if (typeof configured !== "string") {
+        return undefined;
+    }
+    const trimmed = configured.trim();
+    return trimmed.length > 0 ? trimmed : undefined;
+}
+function openClawTimeoutError(label, timeoutMs) {
+    return new Error(`OpenClaw ${label} timed out after ${timeoutMs}ms`);
+}
+function shorten(text, maxLength) {
+    const normalized = text.replace(/\s+/g, " ").trim();
+    if (normalized.length <= maxLength) {
+        return normalized;
+    }
+    return `${normalized.slice(0, maxLength - 1)}…`;
+}
+function base64UrlEncode(buffer) {
+    return buffer.toString("base64").replaceAll("+", "-").replaceAll("/", "_").replace(/=+$/g, "");
+}
+function normalizeAgentIdFromSessionKey(sessionKey) {
+    if (typeof sessionKey !== "string") {
+        return null;
+    }
+    const match = sessionKey.trim().match(/^agent:([^:]+):/i);
+    return match ? match[1].trim().toLowerCase() : null;
+}
+function cachedOpenClawIdentity() {
+    if (cachedIdentity) {
+        return cachedIdentity;
+    }
+    const { publicKey, privateKey } = (0, node_crypto_1.generateKeyPairSync)("ed25519");
+    const publicKeyDer = publicKey.export({ type: "spki", format: "der" });
+    const publicKeyRaw = publicKeyDer.subarray(publicKeyDer.length - 32);
+    cachedIdentity = {
+        deviceId: (0, node_crypto_1.createHash)("sha256").update(publicKeyRaw).digest("hex"),
+        publicKeyRawBase64Url: base64UrlEncode(publicKeyRaw),
+        privateKeyPem: privateKey.export({ type: "pkcs8", format: "pem" }).toString()
+    };
+    return cachedIdentity;
+}
+function buildDeviceAuthPayload(params) {
+    return [
+        "v3",
+        params.deviceId,
+        params.clientId,
+        params.clientMode,
+        params.role,
+        params.scopes.join(","),
+        String(params.signedAtMs),
+        params.token ?? "",
+        params.nonce,
+        params.platform ?? "",
+        params.deviceFamily ?? ""
+    ].join("|");
+}
+function onceSocketEvent(socket, eventType, timeoutMs, predicate) {
+    return new Promise((resolve, reject) => {
+        const timeout = setTimeout(() => {
+            cleanup();
+            reject(openClawTimeoutError(eventType, timeoutMs));
+        }, timeoutMs);
+        const onEvent = (event) => {
+            if (predicate && !predicate(event)) {
+                return;
+            }
+            cleanup();
+            resolve(event);
+        };
+        const cleanup = () => {
+            clearTimeout(timeout);
+            socket.removeEventListener(eventType, onEvent);
+        };
+        socket.addEventListener(eventType, onEvent);
+    });
+}
+function readSocketMessageData(event) {
+    const candidate = typeof event === "object" && event && "data" in event
+        ? event.data
+        : null;
+    if (typeof candidate === "string") {
+        return candidate;
+    }
+    if (candidate instanceof ArrayBuffer) {
+        return Buffer.from(candidate).toString("utf8");
+    }
+    if (ArrayBuffer.isView(candidate)) {
+        return Buffer.from(candidate.buffer, candidate.byteOffset, candidate.byteLength).toString("utf8");
+    }
+    return "";
+}
+class OpenClawGatewayClient {
+    socket;
+    pending = new Map();
+    connectNonce = null;
+    closed = false;
+    constructor(socket) {
+        this.socket = socket;
+        this.socket.addEventListener("message", (event) => this.onMessage(event));
+        this.socket.addEventListener("close", () => this.failAll(new Error("OpenClaw gateway closed")));
+        this.socket.addEventListener("error", () => this.failAll(new Error("OpenClaw gateway error")));
+    }
+    static async connect() {
+        const WebSocketCtor = globalThis.WebSocket;
+        if (typeof WebSocketCtor !== "function") {
+            throw new Error("WebSocket runtime unavailable");
+        }
+        const socket = new WebSocketCtor(openClawGatewayUrl());
+        await onceSocketEvent(socket, "open", OPENCLAW_CONNECT_TIMEOUT_MS);
+        const client = new OpenClawGatewayClient(socket);
+        await client.handshake();
+        return client;
+    }
+    async close() {
+        if (this.closed) {
+            return;
+        }
+        this.closed = true;
+        this.failAll(new Error("OpenClaw gateway client closed"));
+        this.socket.close(1000, "done");
+    }
+    async request(method, params) {
+        if (this.closed) {
+            throw new Error("OpenClaw gateway client already closed");
+        }
+        const id = (0, node_crypto_1.randomUUID)();
+        const frame = JSON.stringify({
+            type: "req",
+            id,
+            method,
+            params
+        });
+        return await new Promise((resolve, reject) => {
+            const timeout = setTimeout(() => {
+                this.pending.delete(id);
+                reject(openClawTimeoutError(method, OPENCLAW_REQUEST_TIMEOUT_MS));
+            }, OPENCLAW_REQUEST_TIMEOUT_MS);
+            this.pending.set(id, {
+                resolve: (value) => resolve(value),
+                reject,
+                timeout
+            });
+            this.socket.send(frame);
+        });
+    }
+    async handshake() {
+        this.connectNonce = await this.waitForConnectChallenge();
+        const identity = cachedOpenClawIdentity();
+        const clientId = "codex-agents-office";
+        const clientMode = "backend";
+        const role = "operator";
+        const scopes = ["operator.read"];
+        const signedAtMs = Date.now();
+        const signaturePayload = buildDeviceAuthPayload({
+            deviceId: identity.deviceId,
+            clientId,
+            clientMode,
+            role,
+            scopes,
+            signedAtMs,
+            token: openClawGatewayToken(),
+            nonce: this.connectNonce,
+            platform: process.platform,
+            deviceFamily: "desktop"
+        });
+        const signature = base64UrlEncode((0, node_crypto_1.sign)(null, Buffer.from(signaturePayload, "utf8"), identity.privateKeyPem));
+        await this.request("connect", {
+            minProtocol: OPENCLAW_PROTOCOL_VERSION,
+            maxProtocol: OPENCLAW_PROTOCOL_VERSION,
+            client: {
+                id: clientId,
+                displayName: "Codex Agents Office",
+                version: "0.1.0",
+                platform: process.platform,
+                mode: clientMode
+            },
+            caps: [],
+            commands: [],
+            role,
+            scopes,
+            auth: openClawGatewayToken() || openClawGatewayPassword()
+                ? {
+                    token: openClawGatewayToken(),
+                    password: openClawGatewayPassword()
+                }
+                : undefined,
+            device: {
+                id: identity.deviceId,
+                publicKey: identity.publicKeyRawBase64Url,
+                signature,
+                signedAt: signedAtMs,
+                nonce: this.connectNonce
+            }
+        });
+    }
+    async waitForConnectChallenge() {
+        return await new Promise((resolve, reject) => {
+            const timeout = setTimeout(() => {
+                cleanup();
+                reject(openClawTimeoutError("connect.challenge", OPENCLAW_CONNECT_TIMEOUT_MS));
+            }, OPENCLAW_CONNECT_TIMEOUT_MS);
+            const onMessage = (event) => {
+                const text = readSocketMessageData(event);
+                if (!text) {
+                    return;
+                }
+                let parsed;
+                try {
+                    parsed = JSON.parse(text);
+                }
+                catch {
+                    return;
+                }
+                if (parsed.type !== "event" || parsed.event !== "connect.challenge") {
+                    return;
+                }
+                const nonce = typeof parsed.payload?.nonce === "string" ? parsed.payload.nonce.trim() : "";
+                if (!nonce) {
+                    return;
+                }
+                cleanup();
+                resolve(nonce);
+            };
+            const cleanup = () => {
+                clearTimeout(timeout);
+                this.socket.removeEventListener("message", onMessage);
+            };
+            this.socket.addEventListener("message", onMessage);
+        });
+    }
+    onMessage(event) {
+        const text = readSocketMessageData(event);
+        if (!text) {
+            return;
+        }
+        let parsed;
+        try {
+            parsed = JSON.parse(text);
+        }
+        catch {
+            return;
+        }
+        if (parsed.type !== "res" || typeof parsed.id !== "string") {
+            return;
+        }
+        const pending = this.pending.get(parsed.id);
+        if (!pending) {
+            return;
+        }
+        this.pending.delete(parsed.id);
+        clearTimeout(pending.timeout);
+        if (parsed.ok) {
+            pending.resolve(parsed.payload);
+            return;
+        }
+        pending.reject(new Error(parsed.error?.message ?? parsed.error?.code ?? "OpenClaw gateway request failed"));
+    }
+    failAll(error) {
+        for (const [id, pending] of this.pending.entries()) {
+            this.pending.delete(id);
+            clearTimeout(pending.timeout);
+            pending.reject(error);
+        }
+    }
+}
+function sessionRowTimestamp(row) {
+    if (typeof row.updatedAt === "number" && Number.isFinite(row.updatedAt)) {
+        return row.updatedAt;
+    }
+    if (typeof row.endedAt === "number" && Number.isFinite(row.endedAt)) {
+        return row.endedAt;
+    }
+    if (typeof row.startedAt === "number" && Number.isFinite(row.startedAt)) {
+        return row.startedAt;
+    }
+    return Number.NaN;
+}
+function workspaceAgentsFromGatewayData(input) {
+    const workspaceAgents = new Map();
+    const configuredAgents = Array.isArray(input.config?.agents?.list) ? input.config.agents.list : [];
+    const defaultWorkspace = (0, project_paths_1.canonicalizeProjectPath)(input.config?.agents?.defaults?.workspace ?? null);
+    const gatewayAgentNames = new Map();
+    for (const agent of input.gatewayAgents) {
+        gatewayAgentNames.set(agent.id.trim().toLowerCase(), agent.name?.trim() || agent.identity?.name?.trim() || null);
+    }
+    for (const configuredAgent of configuredAgents) {
+        const agentId = typeof configuredAgent?.id === "string" ? configuredAgent.id.trim().toLowerCase() : "";
+        if (!agentId) {
+            continue;
+        }
+        const workspaceRoot = (0, project_paths_1.canonicalizeProjectPath)(configuredAgent.workspace ?? null);
+        if (!workspaceRoot) {
+            continue;
+        }
+        workspaceAgents.set(agentId, {
+            agentId,
+            name: configuredAgent.name?.trim()
+                || gatewayAgentNames.get(agentId)
+                || null,
+            workspaceRoot,
+            isDefault: input.defaultAgentId === agentId
+        });
+    }
+    if (input.defaultAgentId && defaultWorkspace && !workspaceAgents.has(input.defaultAgentId)) {
+        workspaceAgents.set(input.defaultAgentId, {
+            agentId: input.defaultAgentId,
+            name: gatewayAgentNames.get(input.defaultAgentId) ?? null,
+            workspaceRoot: defaultWorkspace,
+            isDefault: true
+        });
+    }
+    return [...workspaceAgents.values()];
+}
+function openClawDisplayLabel(params) {
+    return (params.row.label?.trim()
+        || params.row.displayName?.trim()
+        || params.row.derivedTitle?.trim()
+        || params.agent.name?.trim()
+        || params.row.key);
+}
+function openClawLatestMessage(row) {
+    const preview = row.lastMessagePreview?.trim() ?? "";
+    return preview.length > 0 ? preview : null;
+}
+function pathWithinOpenClawProject(projectRoot, candidate) {
+    if (!candidate) {
+        return false;
+    }
+    if ((0, project_paths_1.sameProjectPath)(projectRoot, candidate)) {
+        return true;
+    }
+    const rootKey = (0, project_paths_1.projectPathIdentityKey)(projectRoot);
+    const candidateKey = (0, project_paths_1.projectPathIdentityKey)(candidate);
+    return Boolean(rootKey && candidateKey && candidateKey.startsWith(`${rootKey}/`));
+}
+function openClawWorkspaceInsideAnyProject(workspaceRoot, projectRoots) {
+    if (!workspaceRoot) {
+        return false;
+    }
+    return projectRoots.some((projectRoot) => pathWithinOpenClawProject(projectRoot, workspaceRoot));
+}
+function openClawSessionToActivityState(params) {
+    if (params.activeChildCount > 0) {
+        return "delegating";
+    }
+    switch (params.row.status) {
+        case "running":
+            return "thinking";
+        case "done":
+            return "done";
+        case "failed":
+        case "killed":
+        case "timeout":
+            return "blocked";
+        default:
+            return "idle";
+    }
+}
+function openClawSessionDetail(params) {
+    if (params.activeChildCount > 0) {
+        return `Delegating to ${params.activeChildCount} session${params.activeChildCount === 1 ? "" : "s"}`;
+    }
+    const preview = openClawLatestMessage(params.row);
+    if (preview) {
+        return shorten(preview, 88);
+    }
+    if (params.row.derivedTitle?.trim()) {
+        return shorten(params.row.derivedTitle, 88);
+    }
+    switch (params.row.status) {
+        case "running":
+            return "Thinking";
+        case "done":
+            return "Finished recently";
+        case "failed":
+            return "Session failed";
+        case "killed":
+            return "Session stopped";
+        case "timeout":
+            return "Session timed out";
+        default:
+            return "Idle";
+    }
+}
+function sessionDepthForKey(key, parentByKey, seen = new Set()) {
+    const parent = parentByKey.get(key) ?? null;
+    if (!parent) {
+        return 0;
+    }
+    if (seen.has(key) || seen.has(parent)) {
+        return 1;
+    }
+    seen.add(key);
+    return 1 + sessionDepthForKey(parent, parentByKey, seen);
+}
+function activeOpenClawChildCounts(sessions) {
+    const activeChildCountByKey = new Map();
+    for (const session of sessions) {
+        const parentKey = session.parentSessionKey?.trim() || null;
+        if (!parentKey) {
+            continue;
+        }
+        const state = openClawSessionToActivityState({ row: session, activeChildCount: 0 });
+        if (state === "done" || state === "idle") {
+            continue;
+        }
+        activeChildCountByKey.set(parentKey, (activeChildCountByKey.get(parentKey) ?? 0) + 1);
+    }
+    return activeChildCountByKey;
+}
+async function openClawDashboardAgentFromSession(input) {
+    const updatedAtMs = sessionRowTimestamp(input.session);
+    if (!Number.isFinite(updatedAtMs)) {
+        return null;
+    }
+    const agentId = normalizeAgentIdFromSessionKey(input.session.key);
+    const labelAgent = input.agent ?? {
+        agentId: agentId ?? "openclaw",
+        name: null,
+        workspaceRoot: input.projectRoot,
+        isDefault: false
+    };
+    const activeChildCount = input.activeChildCount;
+    const state = openClawSessionToActivityState({
+        row: input.session,
+        activeChildCount
+    });
+    const sourceKind = input.sourceKind
+        ?? (input.session.modelProvider && input.session.model
+            ? `openclaw:${input.session.modelProvider}/${input.session.model}`
+            : input.session.model
+                ? `openclaw:${input.session.model}`
+                : "openclaw");
+    const appearance = await (0, appearance_1.ensureAgentAppearance)(input.projectRoot, `openclaw:${input.session.key}`);
+    const cwd = input.agent?.workspaceRoot ?? null;
+    return {
+        id: `openclaw:${input.session.key}`,
+        label: openClawDisplayLabel({ row: input.session, agent: labelAgent }),
+        source: "openclaw",
+        sourceKind,
+        parentThreadId: input.session.parentSessionKey ? `openclaw:${input.session.parentSessionKey}` : null,
+        depth: sessionDepthForKey(input.session.key, input.parentByKey),
+        isCurrent: false,
+        isOngoing: input.session.status === "running",
+        statusText: input.statusText ?? input.session.status ?? null,
+        role: labelAgent.isDefault ? (labelAgent.name ?? "openclaw") : labelAgent.agentId,
+        nickname: labelAgent.name,
+        isSubagent: Boolean(input.session.parentSessionKey),
+        state,
+        detail: openClawSessionDetail({ row: input.session, activeChildCount }),
+        cwd,
+        roomId: null,
+        appearance,
+        updatedAt: new Date(updatedAtMs).toISOString(),
+        stoppedAt: typeof input.session.endedAt === "number" && Number.isFinite(input.session.endedAt)
+            ? new Date(input.session.endedAt).toISOString()
+            : null,
+        paths: cwd ? [cwd] : [],
+        activityEvent: null,
+        latestMessage: openClawLatestMessage(input.session),
+        threadId: input.session.key,
+        taskId: null,
+        resumeCommand: null,
+        url: null,
+        git: null,
+        provenance: "openclaw",
+        confidence: "typed",
+        needsUser: null,
+        liveSubscription: "readOnly",
+        network: null
+    };
+}
+async function loadOpenClawWorkspaceDataUncached() {
+    if (!openClawEnabled()) {
+        return null;
+    }
+    const client = await OpenClawGatewayClient.connect();
+    try {
+        const [configResult, agentsResult, sessionsResult] = await Promise.all([
+            client.request("config.get", {}),
+            client.request("agents.list", {}),
+            client.request("sessions.list", {
+                includeGlobal: false,
+                includeUnknown: false,
+                includeDerivedTitles: true,
+                includeLastMessage: true
+            })
+        ]);
+        const defaultAgentId = typeof agentsResult?.defaultId === "string" && agentsResult.defaultId.trim().length > 0
+            ? agentsResult.defaultId.trim().toLowerCase()
+            : null;
+        return {
+            fetchedAt: Date.now(),
+            agents: workspaceAgentsFromGatewayData({
+                config: configResult?.config,
+                gatewayAgents: Array.isArray(agentsResult?.agents) ? agentsResult.agents : [],
+                defaultAgentId
+            }),
+            sessions: Array.isArray(sessionsResult?.sessions) ? sessionsResult.sessions : []
+        };
+    }
+    finally {
+        await client.close();
+    }
+}
+async function loadOpenClawWorkspaceData() {
+    const now = Date.now();
+    if (cachedWorkspaceData && now - cachedWorkspaceDataAt <= OPENCLAW_CACHE_TTL_MS) {
+        return await cachedWorkspaceData;
+    }
+    cachedWorkspaceDataAt = now;
+    cachedWorkspaceData = loadOpenClawWorkspaceDataUncached().catch((error) => {
+        cachedWorkspaceData = null;
+        cachedWorkspaceDataAt = 0;
+        throw error;
+    });
+    return await cachedWorkspaceData;
+}
+function openClawWorkspaceMatchesProject(workspaceRoot, projectRoot) {
+    return pathWithinOpenClawProject(projectRoot, workspaceRoot);
+}
+async function discoverOpenClawProjects(limit = 20) {
+    const data = await loadOpenClawWorkspaceData();
+    if (!data) {
+        return [];
+    }
+    const recentCutoff = Date.now() - OPENCLAW_DISCOVERY_WINDOW_MS;
+    const projects = new Map();
+    const workspaceByAgentId = new Map(data.agents.map((agent) => [agent.agentId, agent.workspaceRoot]));
+    for (const session of data.sessions) {
+        const updatedAt = sessionRowTimestamp(session);
+        if (!Number.isFinite(updatedAt) || updatedAt < recentCutoff) {
+            continue;
+        }
+        const agentId = normalizeAgentIdFromSessionKey(session.key);
+        const workspaceRoot = agentId ? workspaceByAgentId.get(agentId) ?? null : null;
+        if (!workspaceRoot) {
+            continue;
+        }
+        const existing = projects.get(workspaceRoot);
+        if (existing) {
+            existing.updatedAt = Math.max(existing.updatedAt, updatedAt);
+            existing.count += 1;
+            continue;
+        }
+        projects.set(workspaceRoot, {
+            root: workspaceRoot,
+            label: openClawSessionWorkspaceLabel(workspaceRoot) ?? workspaceRoot,
+            updatedAt,
+            count: 1
+        });
+    }
+    return [...projects.values()]
+        .sort((left, right) => right.updatedAt - left.updatedAt)
+        .slice(0, limit);
+}
+async function loadOpenClawAgents(projectRoot) {
+    const data = await loadOpenClawWorkspaceData();
+    if (!data) {
+        return [];
+    }
+    const matchedAgents = data.agents.filter((agent) => openClawWorkspaceMatchesProject(agent.workspaceRoot, projectRoot));
+    if (matchedAgents.length === 0) {
+        return [];
+    }
+    const matchedAgentIds = new Set(matchedAgents.map((agent) => agent.agentId));
+    const agentById = new Map(matchedAgents.map((agent) => [agent.agentId, agent]));
+    const relevantSessions = data.sessions.filter((session) => {
+        const agentId = normalizeAgentIdFromSessionKey(session.key);
+        return Boolean(agentId && matchedAgentIds.has(agentId));
+    });
+    const parentByKey = new Map();
+    for (const session of relevantSessions) {
+        parentByKey.set(session.key, session.parentSessionKey?.trim() || null);
+    }
+    const activeChildCountByKey = activeOpenClawChildCounts(relevantSessions);
+    const agents = [];
+    for (const session of relevantSessions.sort((left, right) => {
+        return sessionRowTimestamp(right) - sessionRowTimestamp(left);
+    })) {
+        const agentId = normalizeAgentIdFromSessionKey(session.key);
+        if (!agentId) {
+            continue;
+        }
+        const agent = agentById.get(agentId);
+        if (!agent) {
+            continue;
+        }
+        const activeChildCount = activeChildCountByKey.get(session.key) ?? 0;
+        const dashboardAgent = await openClawDashboardAgentFromSession({
+            projectRoot,
+            session,
+            agent,
+            parentByKey,
+            activeChildCount
+        });
+        if (dashboardAgent) {
+            agents.push(dashboardAgent);
+        }
+    }
+    return agents;
+}
+async function loadRoamingOpenClawSnapshotData(input) {
+    const anchorRoot = (0, project_paths_1.canonicalizeProjectPath)(input.anchorProjectRoot);
+    if (!anchorRoot) {
+        return { agents: [], notes: [] };
+    }
+    const data = await loadOpenClawWorkspaceData();
+    if (!data) {
+        return { agents: [], notes: [] };
+    }
+    const knownRoots = input.knownProjectRoots
+        .map((root) => (0, project_paths_1.canonicalizeProjectPath)(root))
+        .filter((root) => Boolean(root));
+    const limit = input.limit ?? 4;
+    const recentCutoff = Date.now() - OPENCLAW_DISCOVERY_WINDOW_MS;
+    const agentById = new Map(data.agents.map((agent) => [agent.agentId, agent]));
+    const candidateSessions = data.sessions.filter((session) => {
+        const updatedAt = sessionRowTimestamp(session);
+        if (!Number.isFinite(updatedAt) || updatedAt < recentCutoff) {
+            return false;
+        }
+        const agentId = normalizeAgentIdFromSessionKey(session.key);
+        const agent = agentId ? agentById.get(agentId) ?? null : null;
+        return !openClawWorkspaceInsideAnyProject(agent?.workspaceRoot ?? null, knownRoots);
+    });
+    const parentByKey = new Map();
+    for (const session of candidateSessions) {
+        parentByKey.set(session.key, session.parentSessionKey?.trim() || null);
+    }
+    const activeChildCountByKey = activeOpenClawChildCounts(candidateSessions);
+    const agents = [];
+    for (const session of candidateSessions.sort((left, right) => {
+        return sessionRowTimestamp(right) - sessionRowTimestamp(left);
+    })) {
+        const agentId = normalizeAgentIdFromSessionKey(session.key);
+        const sourceAgent = agentId ? agentById.get(agentId) ?? null : null;
+        const activeChildCount = activeChildCountByKey.get(session.key) ?? 0;
+        const dashboardAgent = await openClawDashboardAgentFromSession({
+            projectRoot: anchorRoot,
+            session,
+            agent: sourceAgent,
+            parentByKey,
+            activeChildCount,
+            sourceKind: "openclaw:roaming",
+            statusText: session.status === "running" ? "roaming" : session.status ?? null
+        });
+        if (!dashboardAgent) {
+            continue;
+        }
+        if (dashboardAgent.state === "idle" && dashboardAgent.isOngoing !== true) {
+            continue;
+        }
+        agents.push(dashboardAgent);
+    }
+    return {
+        agents: agents
+            .sort((left, right) => right.updatedAt.localeCompare(left.updatedAt))
+            .slice(0, limit),
+        notes: []
+    };
+}
+function openClawSessionWorkspaceLabel(workspaceRoot) {
+    const canonical = (0, project_paths_1.canonicalizeProjectPath)(workspaceRoot);
+    if (!canonical) {
+        return null;
+    }
+    return (0, node_path_1.basename)(canonical) || canonical;
+}
+//# sourceMappingURL=openclaw.js.map