@useorgx/openclaw-plugin 0.7.3 → 0.7.5

package/dist/http/index.js

@@ -18,10 +18,12 @@
  *   /orgx/api/runs/:id/actions/:action → run control action
  */
 import { readFileSync, existsSync, readdirSync, statSync, openSync, readSync, closeSync, } from "node:fs";
+import { execFile } from "node:child_process";
 import { homedir } from "node:os";
 import { join, dirname, extname, normalize, resolve, relative, sep } from "node:path";
 import { fileURLToPath } from "node:url";
 import { randomUUID } from "node:crypto";
+import { promisify } from "node:util";
 import { readNextUpQueuePins, removeNextUpQueuePin, setNextUpQueuePinOrder, suppressNextUpQueueItem, upsertNextUpQueuePin, } from "../next-up-queue-store.js";
 import { formatStatus, formatAgents, formatActivity, formatInitiatives, getOnboardingState, } from "../dashboard-api.js";
 import { loadLocalOpenClawSnapshot, loadLocalTurnDetail, toLocalLiveActivity, toLocalLiveAgents, toLocalLiveInitiatives, toLocalSessionTree, } from "../local-openclaw.js";
@@ -1219,6 +1221,8 @@ const IMMUTABLE_FILE_CACHE = new Map();
 const IMMUTABLE_FILE_CACHE_MAX = 128;
 const FILE_PREVIEW_MAX_BYTES = 1_000_000;
 const FILE_PREVIEW_MAX_DIR_ENTRIES = 300;
+const AUTOPILOT_LOGS_DIR = join(homedir(), ".config", "useorgx", "openclaw-plugin", "autopilot-logs");
+const execFileAsync = promisify(execFile);
 function sendJson(res, status, data) {
     const body = JSON.stringify(data);
     res.writeHead(status, {
@@ -1270,6 +1274,50 @@ function resolveFilesystemOpenPath(rawPath) {
     }
     return resolve(process.cwd(), value);
 }
+function resolveAutopilotLogCandidates(runId) {
+    const sanitizedRunId = runId.trim().replaceAll(/[\\/]/g, "");
+    if (!sanitizedRunId)
+        return [];
+    const directCandidates = [
+        join(AUTOPILOT_LOGS_DIR, `${sanitizedRunId}.log`),
+        join(AUTOPILOT_LOGS_DIR, `${sanitizedRunId}.output.json`),
+    ];
+    if (!existsSync(AUTOPILOT_LOGS_DIR)) {
+        return directCandidates;
+    }
+    const discovered = readdirSync(AUTOPILOT_LOGS_DIR)
+        .filter((entry) => entry.startsWith(`${sanitizedRunId}.`))
+        .map((entry) => join(AUTOPILOT_LOGS_DIR, entry))
+        .filter((entry) => entry.endsWith(".log") || entry.endsWith(".output.json"));
+    return dedupeStrings([...directCandidates, ...discovered]);
+}
+async function openPathInTerminal(pathname) {
+    const resolvedPath = resolve(pathname);
+    if (process.platform === "darwin") {
+        const escapedPath = resolvedPath
+            .replaceAll("\\", "\\\\")
+            .replaceAll('"', '\\"');
+        await execFileAsync("osascript", [
+            "-e",
+            'tell application "Terminal" to activate',
+            "-e",
+            `tell application "Terminal" to do script "tail -f \\"${escapedPath}\\""`,
+        ]);
+        return;
+    }
+    if (process.platform === "win32") {
+        await execFileAsync("cmd", ["/c", "start", "", resolvedPath]);
+        return;
+    }
+    try {
+        await execFileAsync("gnome-terminal", ["--", "tail", "-f", resolvedPath]);
+        return;
+    }
+    catch {
+        // Fallback to generic opener when no terminal app is available.
+    }
+    await execFileAsync("xdg-open", [resolvedPath]);
+}
 function readFilePreview(pathname, totalBytes) {
     if (totalBytes <= 0) {
         return { previewBuffer: Buffer.alloc(0), truncated: false };
@@ -3328,6 +3376,7 @@ export function createHttpHandler(config, client, getSnapshot, onboarding, diagn
         loadLocalOpenClawSnapshot,
         toLocalLiveAgents,
         toLocalLiveInitiatives,
+        buildMissionControlGraph: (initiativeId) => buildMissionControlGraph(client, initiativeId),
         localInitiativeStatusOverrides,
         mapDecisionEntity,
         sendJson,
@@ -3369,6 +3418,8 @@ export function createHttpHandler(config, client, getSnapshot, onboarding, diagn
         readFilePreview,
         filePreviewMaxBytes: FILE_PREVIEW_MAX_BYTES,
         filePreviewMaxDirEntries: FILE_PREVIEW_MAX_DIR_ENTRIES,
+        resolveAutopilotLogCandidates,
+        openPathInTerminal,
         securityHeaders: SECURITY_HEADERS,
         corsHeaders: CORS_HEADERS,
         config: {
@@ -3509,10 +3560,116 @@ export function createHttpHandler(config, client, getSnapshot, onboarding, diagn
             }
             return [];
         },
-        getBlockerEvents: () => {
-            // Extract blocker events from recent activity
-            // In future, this will read from a dedicated blocker store
-            return [];
+        getBlockerEvents: (workspaceId) => {
+            const normalizedWorkspaceId = (workspaceId ?? "").trim();
+            const scopedKeys = normalizedWorkspaceId
+                ? [
+                    `live-snapshot:${normalizedWorkspaceId}`,
+                    `live-snapshot-v2:${normalizedWorkspaceId}`,
+                    `dashboard-bundle:${normalizedWorkspaceId}`,
+                ]
+                : [];
+            const fallbackKeys = ["live-snapshot", "dashboard-bundle", "live-snapshot-v2"];
+            const keys = [...scopedKeys, ...fallbackKeys];
+            const seen = new Set();
+            const mapped = [];
+            const deriveFailureType = (eventNameRaw, actionTypeRaw) => {
+                const eventName = (eventNameRaw ?? "").trim().toLowerCase();
+                const actionType = (actionTypeRaw ?? "").trim().toLowerCase();
+                const signature = `${eventName} ${actionType}`;
+                if (!signature.trim())
+                    return null;
+                if (signature.includes("status_updates_buffered"))
+                    return "status_updates_buffered";
+                if (signature.includes("question_answer_failed"))
+                    return "question_answer_failed";
+                if (signature.includes("spawn_guard_rate_limited"))
+                    return "spawn_guard_rate_limited";
+                if (signature.includes("spawn_guard_blocked"))
+                    return "spawn_guard_blocked";
+                if (signature.includes("mcp_handshake_failure") || signature.includes("mcp_handshake")) {
+                    return "mcp_handshake_failure";
+                }
+                if (signature.includes("worker_exit_no_output") ||
+                    signature.includes("worker_exit_without_structured_output") ||
+                    signature.includes("no_structured_output")) {
+                    return "worker_exit_no_output";
+                }
+                if (signature.includes("workspace_conflict"))
+                    return "workspace_conflict";
+                if (signature.includes("budget_exhausted"))
+                    return "budget_exhausted";
+                if (signature.includes("stale_blocked_workstream"))
+                    return "stale_blocked_workstream";
+                return null;
+            };
+            try {
+                for (const key of keys) {
+                    const cached = readSnapshotResponseCache(key);
+                    if (!cached || typeof cached !== "object")
+                        continue;
+                    const activityRaw = cached.activity;
+                    if (!Array.isArray(activityRaw))
+                        continue;
+                    for (const entry of activityRaw) {
+                        if (!entry || typeof entry !== "object")
+                            continue;
+                        const activityRecord = entry;
+                        const metadataRecord = activityRecord.metadata && typeof activityRecord.metadata === "object"
+                            ? activityRecord.metadata
+                            : {};
+                        const failureType = deriveFailureType(pickString(metadataRecord, ["event", "event_name"]), pickString(metadataRecord, ["action_type", "actionType"]));
+                        if (!failureType)
+                            continue;
+                        const runId = pickString(metadataRecord, ["run_id", "source_run_id"]) ?? pickString(activityRecord, ["runId"]);
+                        const workstreamId = pickString(metadataRecord, ["workstream_id", "source_stream_id"]) ??
+                            pickString(activityRecord, ["workstreamId"]);
+                        const taskId = pickString(metadataRecord, ["task_id"]) ?? pickString(activityRecord, ["taskId"]);
+                        const initiativeId = pickString(metadataRecord, ["initiative_id"]) ??
+                            pickString(activityRecord, ["initiativeId"]);
+                        const timestamp = pickString(activityRecord, ["timestamp"]) ??
+                            pickString(metadataRecord, ["timestamp", "created_at"]);
+                        const dedupeId = pickString(activityRecord, ["id"]) ??
+                            `${failureType}:${initiativeId ?? "unknown"}:${workstreamId ?? "unknown"}:${runId ?? "unknown"}:${timestamp ?? "unknown"}`;
+                        if (seen.has(dedupeId))
+                            continue;
+                        seen.add(dedupeId);
+                        mapped.push({
+                            id: dedupeId,
+                            failureType,
+                            reason: pickString(metadataRecord, ["error", "reason", "message"]) ??
+                                pickString(activityRecord, ["description", "summary", "title"]),
+                            provider: pickString(metadataRecord, ["provider"]),
+                            initiativeId,
+                            initiativeTitle: pickString(metadataRecord, ["initiative_title"]) ??
+                                pickString(activityRecord, ["initiativeTitle"]),
+                            workstreamId,
+                            workstreamTitle: pickString(metadataRecord, ["workstream_title"]) ??
+                                pickString(activityRecord, ["workstreamTitle"]),
+                            taskId,
+                            taskTitle: pickString(metadataRecord, ["task_title"]) ?? pickString(activityRecord, ["taskTitle"]),
+                            agentId: pickString(metadataRecord, ["agent_id", "executor_agent_id"]) ??
+                                pickString(activityRecord, ["executorAgentId", "agentId"]),
+                            domain: pickString(metadataRecord, ["domain", "executor_domain"]),
+                            sourceSystem: pickString(metadataRecord, ["source_system", "source"]) ?? "openclaw",
+                            runId,
+                            logPath: pickString(metadataRecord, ["log_path"]),
+                            outputPath: pickString(metadataRecord, ["output_path"]),
+                            metadata: metadataRecord,
+                            timestamp: timestamp ?? undefined,
+                        });
+                    }
+                }
+            }
+            catch {
+                // best effort
+            }
+            mapped.sort((a, b) => {
+                const aTs = Date.parse(String(a.timestamp ?? "")) || 0;
+                const bTs = Date.parse(String(b.timestamp ?? "")) || 0;
+                return bTs - aTs;
+            });
+            return mapped;
         },
         resolveDecisionAction: async (decisionId, action, note, optionId) => {
             try {

package/dist/http/routes/live-legacy.d.ts

@@ -101,6 +101,8 @@ type RegisterLiveLegacyRoutesDeps<TRes extends RouteResLike> = {
     };
     filePreviewMaxBytes: number;
     filePreviewMaxDirEntries: number;
+    resolveAutopilotLogCandidates?: (runId: string) => string[];
+    openPathInTerminal?: (path: string) => Promise<void>;
     securityHeaders: Record<string, string>;
     corsHeaders: Record<string, string>;
     config: {

package/dist/http/routes/live-legacy.js

@@ -1,4 +1,30 @@
 export function registerLiveLegacyRoutes(router, deps) {
+    function toContextBundle(value) {
+        return {
+            agents: value.agents ?? {},
+            runs: value.runs ?? {},
+        };
+    }
+    function parseWorkspaceScope(query) {
+        const candidates = [
+            query.get("workspace_id"),
+            query.get("workspaceId"),
+            query.get("command_center_id"),
+            query.get("commandCenterId"),
+            query.get("center"),
+            query.get("project_id"),
+            query.get("projectId"),
+        ];
+        for (const candidate of candidates) {
+            if (typeof candidate !== "string")
+                continue;
+            const normalized = candidate.trim();
+            if (!normalized || normalized.toLowerCase() === "all")
+                continue;
+            return normalized;
+        }
+        return null;
+    }
     const sendDeprecated = (res, endpoint, replacement) => {
         deps.sendJson(res, 410, {
             error: `${endpoint} is deprecated`,
@@ -14,9 +40,69 @@ export function registerLiveLegacyRoutes(router, deps) {
     router.add("GET", "live/sessions", async ({ query, res }) => renderLiveSessions(query, res), "Legacy live sessions endpoint");
     router.add("HEAD", "live/sessions", async ({ query, res }) => renderLiveSessions(query, res), "Legacy live sessions endpoint (HEAD)");
     async function renderLiveActivityPage(query, res) {
-        sendDeprecated(res, "/orgx/api/live/activity/page", "/orgx/api/live/snapshot-v2");
-        void query;
-        return;
+        const run = query.get("run");
+        const since = query.get("since");
+        const until = query.get("until");
+        const cursor = query.get("cursor");
+        const projectId = parseWorkspaceScope(query);
+        const limitRaw = query.get("limit") ? Number(query.get("limit")) : undefined;
+        const limit = Number.isFinite(limitRaw)
+            ? Math.max(1, Math.floor(Number(limitRaw)))
+            : 200;
+        let page = deps.listActivityPage({
+            limit,
+            runId: run,
+            since,
+            until,
+            cursor,
+        });
+        {
+            const ctx = toContextBundle(deps.readAgentContexts());
+            page = {
+                ...page,
+                activities: deps.applyAgentContextsToActivity(page.activities, ctx),
+            };
+        }
+        const warmKey = `${projectId ?? ""}::${run ?? ""}::${since ?? ""}::${until ?? ""}`;
+        const lastWarmAt = deps.activityWarmByKey.get(warmKey) ?? 0;
+        const shouldWarm = Date.now() - lastWarmAt > deps.activityWarmThrottleMs &&
+            (cursor === null || cursor === "" || page.activities.length < limit);
+        if (shouldWarm) {
+            deps.activityWarmByKey.set(warmKey, Date.now());
+            try {
+                const warmLimit = Math.max(800, Math.min(6_000, limit * 10));
+                const data = await deps.getLiveActivity({
+                    run,
+                    since,
+                    projectId,
+                    limit: warmLimit,
+                });
+                const remote = Array.isArray(data.activities) ? data.activities : [];
+                {
+                    const ctx = toContextBundle(deps.readAgentContexts());
+                    const withContexts = deps.applyAgentContextsToActivity(remote, ctx);
+                    deps.appendActivityItems(withContexts);
+                }
+                page = deps.listActivityPage({
+                    limit,
+                    runId: run,
+                    since,
+                    until,
+                    cursor,
+                });
+                {
+                    const ctx = toContextBundle(deps.readAgentContexts());
+                    page = {
+                        ...page,
+                        activities: deps.applyAgentContextsToActivity(page.activities, ctx),
+                    };
+                }
+            }
+            catch {
+                // best effort
+            }
+        }
+        deps.sendJson(res, 200, page);
     }
     router.add("GET", "live/activity/page", async ({ query, res }) => renderLiveActivityPage(query, res), "Paginated live activity");
     router.add("HEAD", "live/activity/page", async ({ query, res }) => renderLiveActivityPage(query, res), "Paginated live activity (HEAD)");
@@ -101,6 +187,64 @@ export function registerLiveLegacyRoutes(router, deps) {
     router.add("*", "live/filesystem/open", ({ res }) => {
         deps.sendJson(res, 405, { error: "Use GET /orgx/api/live/filesystem/open?path=..." });
     }, "Reject unsupported methods for live/filesystem/open");
+    router.add("POST", "live/terminal/open", async ({ body, res }) => {
+        const payload = body && typeof body === "object" && !Array.isArray(body)
+            ? body
+            : {};
+        const runId = typeof payload.runId === "string" ? payload.runId.trim() : "";
+        const rawPath = typeof payload.path === "string" ? payload.path.trim() : "";
+        if (!runId && !rawPath) {
+            deps.sendJson(res, 400, {
+                ok: false,
+                error: "runId or path is required",
+            });
+            return;
+        }
+        let resolvedPath = "";
+        if (rawPath) {
+            resolvedPath = deps.resolveFilesystemOpenPath(rawPath);
+        }
+        else if (runId) {
+            const candidates = deps.resolveAutopilotLogCandidates
+                ? deps.resolveAutopilotLogCandidates(runId)
+                : [];
+            resolvedPath =
+                candidates.find((candidate) => deps.existsSync(candidate)) ?? "";
+        }
+        if (!resolvedPath || !deps.existsSync(resolvedPath)) {
+            deps.sendJson(res, 404, {
+                ok: false,
+                error: "Terminal target not found",
+            });
+            return;
+        }
+        if (!deps.openPathInTerminal) {
+            deps.sendJson(res, 501, {
+                ok: false,
+                error: "Terminal open is unavailable in this runtime.",
+            });
+            return;
+        }
+        try {
+            await deps.openPathInTerminal(resolvedPath);
+            deps.sendJson(res, 200, {
+                ok: true,
+                path: resolvedPath,
+            });
+        }
+        catch (err) {
+            deps.sendJson(res, 500, {
+                ok: false,
+                error: deps.safeErrorMessage(err),
+            });
+        }
+    }, "Open run logs in local terminal");
+    router.add("*", "live/terminal/open", ({ res }) => {
+        deps.sendJson(res, 405, {
+            ok: false,
+            error: "Use POST /orgx/api/live/terminal/open",
+        });
+    }, "Reject unsupported methods for live/terminal/open");
     async function renderLiveStream(query, req, res) {
         sendDeprecated(res, "/orgx/api/live/stream", "/orgx/api/live/snapshot-v2");
         void query;
@@ -109,4 +253,43 @@ export function registerLiveLegacyRoutes(router, deps) {
     }
     router.add("GET", "live/stream", async ({ query, req, res }) => renderLiveStream(query, req, res), "Proxy live SSE stream");
     router.add("HEAD", "live/stream", async ({ query, req, res }) => renderLiveStream(query, req, res), "Proxy live SSE stream (HEAD)");
+    router.add("POST", "live/terminal/open", async ({ body, res }) => {
+        try {
+            const payload = (typeof body === "string" ? JSON.parse(body) : body);
+            const runId = payload?.runId;
+            if (!runId) {
+                deps.sendJson(res, 400, { error: "runId is required" });
+                return;
+            }
+            const os = await import("os");
+            const cp = await import("child_process");
+            const path = await import("path");
+            const homedir = os.homedir();
+            const logPath = path.join(homedir, ".config", "useorgx", "openclaw-plugin", "autopilot-logs", `${runId}.log`);
+            if (!deps.existsSync(logPath)) {
+                deps.sendJson(res, 404, { error: `Log file not found: ${logPath}` });
+                return;
+            }
+            const shellPath = logPath.replaceAll("'", "'\\''");
+            let command = "";
+            if (os.platform() === "darwin") {
+                command = `osascript -e 'tell app "Terminal" to do script "tail -f \\"${shellPath}\\""'`;
+            }
+            else if (os.platform() === "win32") {
+                command = `start cmd.exe /k "tail -f \\"${shellPath}\\""`;
+            }
+            else {
+                command = `gnome-terminal -- bash -c "tail -f \\"${shellPath}\\"; exec bash"`;
+            }
+            cp.exec(command, (error) => {
+                if (error) {
+                    console.error("Failed to open terminal:", error);
+                }
+            });
+            deps.sendJson(res, 200, { success: true });
+        }
+        catch (err) {
+            deps.sendJson(res, 500, { error: deps.safeErrorMessage(err) });
+        }
+    }, "Open run session in native terminal");
 }

package/dist/http/routes/live-misc.d.ts

@@ -71,6 +71,7 @@ type RegisterLiveMiscRoutesDeps<TReq, TRes> = {
         status: string;
         updatedAt: string;
     }>;
+    buildMissionControlGraph?: (initiativeId: string) => Promise<unknown>;
     mapDecisionEntity: (entry: Entity) => {
         waitingMinutes: number;
     };

package/dist/http/routes/live-misc.js

@@ -1,4 +1,5 @@
 import { resolveWorkspaceScope, workspaceScopeFromHeaders, } from "../helpers/workspace-scope.js";
+import { summarizeTaskStatuses } from "../../reporting/rollups.js";
 function asRecord(input) {
     if (!input || typeof input !== "object" || Array.isArray(input))
         return null;
@@ -423,4 +424,79 @@ export function registerLiveMiscRoutes(router, deps) {
     }
     router.add("GET", "handoffs", async ({ res }) => renderHandoffs(res), "Get handoffs");
     router.add("HEAD", "handoffs", async ({ res }) => renderHandoffs(res), "Get handoffs (HEAD)");
+    router.add("GET", "live/initiatives/summary", async ({ query, res, req }) => {
+        try {
+            const scope = resolveWorkspaceScope(query, workspaceScopeFromHeaders(req?.headers), { allowProjectScope: false });
+            if (scope.error) {
+                deps.sendJson(res, 400, { error: scope.error });
+                return;
+            }
+            const workspaceId = scope.workspaceId;
+            const projectInitiatives = await resolveProjectInitiativeSet(workspaceId);
+            // Load initiatives
+            const local = deps.toLocalLiveInitiatives(await deps.loadLocalOpenClawSnapshot(240));
+            let initiatives = local.initiatives;
+            if (projectInitiatives) {
+                initiatives = initiatives.filter((item) => projectInitiatives.has(item.id));
+            }
+            const perInitiative = [];
+            let totalTasks = 0;
+            let doneTasks = 0;
+            let blockedCount = 0;
+            let activeCount = 0;
+            let totalActiveAgents = 0;
+            for (const initiative of initiatives) {
+                totalActiveAgents += initiative.activeAgents;
+                // Try to get task statuses from graph
+                let taskStatuses = [];
+                if (deps.buildMissionControlGraph) {
+                    try {
+                        const graphRaw = await deps.buildMissionControlGraph(initiative.id);
+                        const graph = asRecord(graphRaw);
+                        const nodes = Array.isArray(graph?.nodes) ? graph.nodes : [];
+                        for (const nodeEntry of nodes) {
+                            const node = asRecord(nodeEntry);
+                            if (!node)
+                                continue;
+                            const type = pickStringFromRecord(node, ["type"]);
+                            if (type !== "task")
+                                continue;
+                            const status = pickStringFromRecord(node, ["status"]) ?? "todo";
+                            taskStatuses.push(status);
+                        }
+                    }
+                    catch {
+                        // Graph unavailable — fall back to empty counts
+                    }
+                }
+                const counts = summarizeTaskStatuses(taskStatuses);
+                const progressPct = counts.total > 0 ? Math.round((counts.done / counts.total) * 100) : 0;
+                perInitiative.push({
+                    id: initiative.id,
+                    taskCounts: counts,
+                    progressPct,
+                });
+                totalTasks += counts.total;
+                doneTasks += counts.done;
+                blockedCount += counts.blocked;
+                activeCount += counts.active;
+            }
+            const completionPercent = totalTasks > 0 ? Math.round((doneTasks / totalTasks) * 100) : 0;
+            deps.sendJson(res, 200, {
+                initiatives: perInitiative,
+                aggregate: {
+                    totalTasks,
+                    doneTasks,
+                    blockedCount,
+                    activeAgents: totalActiveAgents,
+                    completionPercent,
+                },
+            });
+        }
+        catch (err) {
+            deps.sendJson(res, 500, {
+                error: deps.safeErrorMessage(err),
+            });
+        }
+    }, "Get live initiatives summary");
 }

package/dist/http/routes/mission-control-read.d.ts

@@ -41,6 +41,10 @@ type NextUpQueueItem = {
     pinnedRank?: number | null;
     compositeScore?: number;
     scoringTier?: "urgent" | "ready" | "waiting" | "deferred";
+    objectiveScore?: number;
+    roiPerToken?: number;
+    expectedTokens?: number;
+    expectedValueUsd?: number;
     updatedAt?: string | null;
 };
 type SliceRunnerAgent = {