@useorgx/openclaw-plugin 0.4.8 → 0.7.0

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

@@ -0,0 +1,11 @@
+import type { Router } from "../router.js";
+type RegisterLiveTerminalRoutesDeps<TReq, TRes> = {
+    parseJsonRequest: (req: TReq) => Promise<Record<string, unknown>>;
+    sendJson: (res: TRes, status: number, payload: unknown) => void;
+    safeErrorMessage: (err: unknown) => string;
+};
+export declare function escapeShellSingleQuotedArg(value: string): string;
+export declare function hasParentTraversalSegment(rawPath: string): boolean;
+export declare function resolveSafeLogPath(logsDir: string, rawPath: string): string | null;
+export declare function registerLiveTerminalRoutes<TReq, TRes>(router: Router<Record<string, never>, TReq, TRes>, deps: RegisterLiveTerminalRoutesDeps<TReq, TRes>): void;
+export {};

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

@@ -0,0 +1,261 @@
+import { exec } from "node:child_process";
+import { closeSync, existsSync, openSync, readSync, statSync } from "node:fs";
+import { platform } from "node:os";
+import { join, resolve, sep } from "node:path";
+import { getOrgxPluginConfigDir } from "../../paths.js";
+export function escapeShellSingleQuotedArg(value) {
+    return `'${value.replaceAll("'", "'\\''")}'`;
+}
+const DEFAULT_TAIL_LINES = 120;
+const MAX_TAIL_LINES = 400;
+const MAX_TAIL_BYTES = 256 * 1024;
+function pickString(input, keys) {
+    for (const key of keys) {
+        const value = input[key];
+        if (typeof value !== "string")
+            continue;
+        const trimmed = value.trim();
+        if (trimmed.length > 0)
+            return trimmed;
+    }
+    return null;
+}
+function resolveLogsDir() {
+    return resolve(getOrgxPluginConfigDir(), "autopilot-logs");
+}
+export function hasParentTraversalSegment(rawPath) {
+    return rawPath.split(/[\\/]+/).some((segment) => segment === "..");
+}
+export function resolveSafeLogPath(logsDir, rawPath) {
+    if (rawPath.includes("\0"))
+        return null;
+    const isAbsolute = rawPath.startsWith("/") || rawPath.startsWith("\\");
+    if (!isAbsolute && hasParentTraversalSegment(rawPath))
+        return null;
+    const candidate = isAbsolute ? resolve(rawPath) : resolve(logsDir, rawPath);
+    const base = logsDir.endsWith(sep) ? logsDir : `${logsDir}${sep}`;
+    if (!candidate.startsWith(base))
+        return null;
+    return existsSync(candidate) ? candidate : null;
+}
+function resolveLogPathFromIds(logsDir, ids) {
+    for (const rawId of ids) {
+        const id = rawId.trim();
+        if (!isSafeLogId(id))
+            continue;
+        const candidates = [join(logsDir, id), join(logsDir, `${id}.log`), join(logsDir, `${id}.output.json`)];
+        for (const candidate of candidates) {
+            if (existsSync(candidate))
+                return candidate;
+        }
+    }
+    return null;
+}
+function isSafeLogId(input) {
+    if (input.length === 0 || input.length > 128)
+        return false;
+    if (input === "." || input === ".." || input.includes(".."))
+        return false;
+    return /^[A-Za-z0-9._-]+$/.test(input);
+}
+function openPathInTerminal(targetPath) {
+    return new Promise((resolvePromise, rejectPromise) => {
+        const os = platform();
+        const pathArg = escapeShellSingleQuotedArg(targetPath);
+        const tailCmd = `tail -f ${pathArg}`;
+        const tailCmdArg = escapeShellSingleQuotedArg(tailCmd);
+        let cmd;
+        if (os === "darwin") {
+            cmd = `osascript -e 'tell application "Terminal" to do script ${JSON.stringify(tailCmd)}'`;
+        }
+        else if (os === "linux") {
+            cmd = `gnome-terminal -- bash -lc ${tailCmdArg} 2>/dev/null || xterm -e bash -lc ${tailCmdArg}`;
+        }
+        else {
+            rejectPromise(new Error(`Terminal open not supported on ${os}`));
+            return;
+        }
+        exec(cmd, (err) => {
+            if (err)
+                rejectPromise(err);
+            else
+                resolvePromise();
+        });
+    });
+}
+function openPathInEditor(targetPath) {
+    return new Promise((resolvePromise, rejectPromise) => {
+        const pathArg = escapeShellSingleQuotedArg(targetPath);
+        const os = platform();
+        const cmd = os === "darwin"
+            ? `cursor ${pathArg} 2>/dev/null || code ${pathArg} 2>/dev/null || open ${pathArg} 2>/dev/null`
+            : os === "linux"
+                ? `cursor ${pathArg} 2>/dev/null || code ${pathArg} 2>/dev/null || xdg-open ${pathArg} 2>/dev/null`
+                : "";
+        if (!cmd) {
+            rejectPromise(new Error(`Editor open not supported on ${os}`));
+            return;
+        }
+        exec(cmd, (err) => {
+            if (err)
+                rejectPromise(err);
+            else
+                resolvePromise();
+        });
+    });
+}
+function resolveTargetPath(payload) {
+    const logsDir = resolveLogsDir();
+    const explicitPath = pickString(payload, [
+        "logPath",
+        "log_path",
+        "path",
+        "sessionPath",
+        "session_path",
+    ]);
+    if (explicitPath) {
+        const resolved = resolveSafeLogPath(logsDir, explicitPath);
+        if (resolved)
+            return resolved;
+    }
+    const ids = [
+        pickString(payload, ["sliceRunId", "slice_run_id"]),
+        pickString(payload, ["runId", "run_id"]),
+        pickString(payload, ["sessionId", "session_id"]),
+    ].filter((value) => Boolean(value));
+    if (ids.length > 0) {
+        return resolveLogPathFromIds(logsDir, ids);
+    }
+    return null;
+}
+function parseTailLines(raw) {
+    if (!raw)
+        return DEFAULT_TAIL_LINES;
+    const parsed = Number(raw);
+    if (!Number.isFinite(parsed))
+        return DEFAULT_TAIL_LINES;
+    const normalized = Math.floor(parsed);
+    if (normalized <= 0)
+        return DEFAULT_TAIL_LINES;
+    return Math.min(MAX_TAIL_LINES, normalized);
+}
+function readLogTailPreview(path, lineLimit) {
+    const stats = statSync(path);
+    if (!stats.isFile()) {
+        throw new Error("Tail target is not a file.");
+    }
+    const totalBytes = Number.isFinite(stats.size) ? Math.max(0, stats.size) : 0;
+    const offsetBytes = Math.max(0, totalBytes - MAX_TAIL_BYTES);
+    const readLength = Math.max(0, totalBytes - offsetBytes);
+    if (readLength === 0) {
+        return {
+            text: "",
+            lineCount: 0,
+            truncated: false,
+            totalBytes,
+            offsetBytes,
+            updatedAt: stats.mtime.toISOString(),
+        };
+    }
+    const fd = openSync(path, "r");
+    try {
+        const buffer = Buffer.allocUnsafe(readLength);
+        let bytesRead = 0;
+        while (bytesRead < readLength) {
+            const chunk = readSync(fd, buffer, bytesRead, readLength - bytesRead, offsetBytes + bytesRead);
+            if (chunk <= 0)
+                break;
+            bytesRead += chunk;
+        }
+        const normalizedText = buffer
+            .subarray(0, Math.max(0, bytesRead))
+            .toString("utf8")
+            .replaceAll("\r\n", "\n")
+            .replaceAll("\r", "\n");
+        const allLines = normalizedText.split("\n");
+        if (allLines.length > 0 && allLines[allLines.length - 1] === "") {
+            allLines.pop();
+        }
+        const tailLines = allLines.slice(-lineLimit);
+        const truncated = offsetBytes > 0 || allLines.length > tailLines.length;
+        return {
+            text: tailLines.join("\n"),
+            lineCount: tailLines.length,
+            truncated,
+            totalBytes,
+            offsetBytes,
+            updatedAt: stats.mtime.toISOString(),
+        };
+    }
+    finally {
+        closeSync(fd);
+    }
+}
+export function registerLiveTerminalRoutes(router, deps) {
+    router.add("GET", "live/terminal/tail", ({ query, res }) => {
+        try {
+            const payload = {
+                path: query.get("path"),
+                logPath: query.get("logPath"),
+                log_path: query.get("log_path"),
+                sliceRunId: query.get("sliceRunId"),
+                slice_run_id: query.get("slice_run_id"),
+                runId: query.get("runId"),
+                run_id: query.get("run_id"),
+                sessionId: query.get("sessionId"),
+                session_id: query.get("session_id"),
+            };
+            const targetPath = resolveTargetPath(payload);
+            if (!targetPath) {
+                deps.sendJson(res, 404, {
+                    error: "Tail target not found. Provide runId, sliceRunId, sessionId, or logPath/path.",
+                });
+                return;
+            }
+            const lineLimit = parseTailLines(query.get("lines") ?? query.get("line_count"));
+            const preview = readLogTailPreview(targetPath, lineLimit);
+            deps.sendJson(res, 200, {
+                ok: true,
+                path: targetPath,
+                lines_requested: lineLimit,
+                line_count: preview.lineCount,
+                truncated: preview.truncated,
+                bytes: preview.totalBytes,
+                offset_bytes: preview.offsetBytes,
+                updated_at: preview.updatedAt,
+                text: preview.text,
+            });
+        }
+        catch (err) {
+            deps.sendJson(res, 500, { error: deps.safeErrorMessage(err) });
+        }
+    }, "Read a safe tail preview for run/session logs");
+    router.add("*", "live/terminal/tail", ({ res }) => {
+        deps.sendJson(res, 405, { error: "Use GET /orgx/api/live/terminal/tail" });
+    }, "Reject unsupported methods for live/terminal/tail");
+    router.add("POST", "live/terminal/open", async ({ req, res }) => {
+        try {
+            const payload = await deps.parseJsonRequest(req);
+            const targetPath = resolveTargetPath(payload);
+            if (!targetPath) {
+                deps.sendJson(res, 404, {
+                    error: "Terminal target not found. Provide runId, sliceRunId, sessionId, or logPath.",
+                });
+                return;
+            }
+            try {
+                await openPathInTerminal(targetPath);
+            }
+            catch {
+                await openPathInEditor(targetPath);
+            }
+            deps.sendJson(res, 200, { ok: true, path: targetPath });
+        }
+        catch (err) {
+            deps.sendJson(res, 500, { error: deps.safeErrorMessage(err) });
+        }
+    }, "Open run/session logs in terminal or editor");
+    router.add("*", "live/terminal/open", ({ res }) => {
+        deps.sendJson(res, 405, { error: "Use POST /orgx/api/live/terminal/open" });
+    }, "Reject unsupported methods for live/terminal/open");
+}

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

@@ -0,0 +1,61 @@
+/**
+ * Triage queue API routes.
+ *
+ * GET  /live/triage        – list open triage items (merged decisions + blockers)
+ * POST /live/triage/:id/action – act on a triage item
+ */
+import type { LiveDecision } from "../../contracts/shared-types.js";
+interface Router<TState, TReq, TRes> {
+    add(method: string, path: string, handler: (ctx: {
+        req: TReq;
+        res: TRes;
+        path: string;
+        query: URLSearchParams;
+        body: unknown;
+        state: TState;
+    }) => Promise<void>, description?: string): void;
+}
+export interface RegisterLiveTriageRoutesDeps<TReq, TRes> {
+    parseJsonRequest: (req: TReq) => Promise<Record<string, unknown>>;
+    sendJson: (res: TRes, status: number, body: unknown) => void;
+    getDecisions: (workspaceId?: string | null) => LiveDecision[];
+    getBlockerEvents: (workspaceId?: string | null) => Array<{
+        id: string;
+        failureType: string;
+        reason?: string | null;
+        provider?: string | null;
+        initiativeId?: string | null;
+        initiativeTitle?: string | null;
+        workstreamId?: string | null;
+        workstreamTitle?: string | null;
+        taskId?: string | null;
+        taskTitle?: string | null;
+        agentId?: string | null;
+        domain?: string | null;
+        sourceSystem?: string | null;
+        runId?: string | null;
+        logPath?: string | null;
+        outputPath?: string | null;
+        metadata?: Record<string, unknown>;
+        timestamp?: string;
+    }>;
+    resolveDecisionAction: (decisionId: string, action: string, note?: string | null, optionId?: string | null) => Promise<{
+        ok: boolean;
+        error?: string;
+    }>;
+    emitDecisionResolvedActivity?: (input: {
+        ids: string[];
+        action: "approve" | "reject";
+        note?: string | null;
+        optionId?: string | null;
+        initiativeId?: string | null;
+    }) => Promise<void>;
+    snoozeTriage?: (itemId: string, durationMinutes: number) => Promise<{
+        ok: boolean;
+    }>;
+    dismissTriage?: (itemId: string, note?: string) => Promise<{
+        ok: boolean;
+    }>;
+}
+export declare function registerLiveTriageRoutes<TReq, TRes>(router: Router<Record<string, never>, TReq, TRes>, deps: RegisterLiveTriageRoutesDeps<TReq, TRes>): void;
+export {};

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

@@ -0,0 +1,248 @@
+/**
+ * Triage queue API routes.
+ *
+ * GET  /live/triage        – list open triage items (merged decisions + blockers)
+ * POST /live/triage/:id/action – act on a triage item
+ */
+import { mapDecisionToTriageItem, mapFailureToTriageItem, deduplicateTriageItems, } from "../helpers/triage-mapper.js";
+export function registerLiveTriageRoutes(router, deps) {
+    // ─── GET /live/triage ─────────────────────────────────────────────
+    router.add("GET", "live/triage", async ({ res, query }) => {
+        const workspaceId = query.get("workspace_id") || null;
+        const statusFilter = query.get("status") || "open";
+        const limitStr = query.get("limit");
+        const limit = limitStr ? Math.min(Math.max(1, parseInt(limitStr, 10) || 50), 200) : 50;
+        // Noise reduction query params
+        const noiseThreshold = (query.get("noise_threshold") ?? "medium");
+        const dedupWindowStr = query.get("dedup_window");
+        const dedupWindowMs = dedupWindowStr != null
+            ? Math.max(0, parseInt(dedupWindowStr, 10) || 60000)
+            : 60000;
+        const degraded = [];
+        // 1. Map existing decisions to triage items
+        let decisionItems = [];
+        try {
+            const decisions = deps.getDecisions(workspaceId);
+            decisionItems = decisions
+                .filter((d) => d.status === "pending")
+                .map(mapDecisionToTriageItem);
+        }
+        catch {
+            degraded.push("decisions");
+        }
+        // 2. Map blocker events to triage items
+        let blockerItems = [];
+        try {
+            const blockerEvents = deps.getBlockerEvents(workspaceId);
+            blockerItems = await Promise.all(blockerEvents.map((event) => mapFailureToTriageItem(event)));
+        }
+        catch {
+            degraded.push("blockers");
+        }
+        // 3. Merge and deduplicate
+        let allItems = deduplicateTriageItems([...decisionItems, ...blockerItems]);
+        // 4. Filter by status
+        if (statusFilter !== "all") {
+            allItems = allItems.filter((item) => item.status === statusFilter);
+        }
+        // 5. Apply noise threshold — suppress low-severity items based on threshold
+        if (noiseThreshold === "high") {
+            // Only show critical and high severity
+            allItems = allItems.filter((item) => item.severity === "critical" || item.severity === "high");
+        }
+        else if (noiseThreshold === "medium") {
+            // Suppress low-severity routine items (review_required with low severity)
+            allItems = allItems.filter((item) => {
+                if (item.severity === "low" &&
+                    item.kind === "review_required") {
+                    return false;
+                }
+                return true;
+            });
+        }
+        // noiseThreshold === 'low' — show everything (no filtering)
+        // 6. Dedup by title within window — group items with the same title
+        //    that occurred within dedupWindowMs of each other, keeping the most recent.
+        if (dedupWindowMs > 0) {
+            const seen = new Map();
+            for (const item of allItems) {
+                const key = item.title.trim().toLowerCase();
+                const ts = new Date(item.lastSeenAt).getTime();
+                const existing = seen.get(key);
+                if (!existing) {
+                    seen.set(key, { item, ts, count: 1 });
+                    continue;
+                }
+                if (Math.abs(existing.ts - ts) <= dedupWindowMs) {
+                    existing.count += 1;
+                    // Keep the more recent item
+                    if (ts > existing.ts) {
+                        existing.item = item;
+                        existing.ts = ts;
+                    }
+                }
+                else {
+                    // Outside window — keep as separate under a unique key
+                    seen.set(`${key}::${item.id}`, { item, ts, count: 1 });
+                }
+            }
+            allItems = Array.from(seen.values()).map((entry) => {
+                // Encode occurrence count so clients can show "N similar" badge
+                const merged = { ...entry.item };
+                if (entry.count > 1) {
+                    merged.occurrenceCount = Math.max(merged.occurrenceCount, entry.count);
+                }
+                return merged;
+            });
+        }
+        // 7. Sort: critical first, then by impact, then recency
+        allItems.sort((a, b) => {
+            const severityOrder = {
+                critical: 0,
+                high: 1,
+                medium: 2,
+                low: 3,
+            };
+            const sevDiff = (severityOrder[a.severity] ?? 3) - (severityOrder[b.severity] ?? 3);
+            if (sevDiff !== 0)
+                return sevDiff;
+            const impactA = a.impact.initiativeCount +
+                a.impact.workstreamCount +
+                a.impact.downstreamBlockedCount;
+            const impactB = b.impact.initiativeCount +
+                b.impact.workstreamCount +
+                b.impact.downstreamBlockedCount;
+            if (impactB !== impactA)
+                return impactB - impactA;
+            return (new Date(b.lastSeenAt).getTime() - new Date(a.lastSeenAt).getTime());
+        });
+        const total = allItems.length;
+        const items = allItems.slice(0, limit);
+        const response = {
+            ok: true,
+            items,
+            total,
+            generatedAt: new Date().toISOString(),
+            ...(degraded.length > 0 ? { degraded } : {}),
+        };
+        deps.sendJson(res, 200, response);
+    }, "List triage items (merged decisions + blockers)");
+    // ─── POST /live/triage/:id/action ─────────────────────────────────
+    router.add("POST", "live/triage/action", async ({ req, res, query }) => {
+        const itemId = query.get("id");
+        if (!itemId) {
+            deps.sendJson(res, 400, { ok: false, error: "Missing triage item id" });
+            return;
+        }
+        let body;
+        try {
+            body = await deps.parseJsonRequest(req);
+        }
+        catch {
+            deps.sendJson(res, 400, { ok: false, error: "Invalid JSON body" });
+            return;
+        }
+        const action = typeof body.action === "string" ? body.action : null;
+        if (!action) {
+            deps.sendJson(res, 400, { ok: false, error: "Missing action field" });
+            return;
+        }
+        const note = typeof body.note === "string" ? body.note : null;
+        const optionIdRaw = typeof body.option_id === "string"
+            ? body.option_id
+            : typeof body.optionId === "string"
+                ? body.optionId
+                : null;
+        const optionId = typeof optionIdRaw === "string" ? optionIdRaw : null;
+        const snoozeDurationMinutes = typeof body.snoozeDurationMinutes === "number"
+            ? body.snoozeDurationMinutes
+            : null;
+        const sideEffects = [];
+        let itemStatus = "open";
+        let continuationPlan = null;
+        // Route action based on item type
+        if (itemId.startsWith("triage-decision-")) {
+            const decisionId = itemId.replace("triage-decision-", "");
+            if (action === "approve" || action === "reject") {
+                const result = await deps.resolveDecisionAction(decisionId, action, note, optionId);
+                if (!result.ok) {
+                    deps.sendJson(res, 500, {
+                        ok: false,
+                        error: result.error ?? "Decision action failed",
+                    });
+                    return;
+                }
+                if (typeof deps.emitDecisionResolvedActivity === "function") {
+                    try {
+                        await deps.emitDecisionResolvedActivity({
+                            ids: [decisionId],
+                            action,
+                            note,
+                            optionId,
+                        });
+                    }
+                    catch {
+                        // best effort
+                    }
+                }
+                itemStatus = "resolved";
+                sideEffects.push(action === "approve"
+                    ? "Decision approved; agent will continue."
+                    : "Decision rejected; agent paused.");
+                continuationPlan =
+                    action === "approve"
+                        ? "Agent will resume with approved direction."
+                        : null;
+            }
+            else if (action === "snooze" && deps.snoozeTriage) {
+                await deps.snoozeTriage(itemId, snoozeDurationMinutes ?? 60);
+                itemStatus = "snoozed";
+                sideEffects.push(`Snoozed for ${snoozeDurationMinutes ?? 60} minutes.`);
+            }
+            else if (action === "dismiss" && deps.dismissTriage) {
+                await deps.dismissTriage(itemId, note ?? undefined);
+                itemStatus = "dismissed";
+                sideEffects.push("Dismissed. Will not re-raise until root cause changes.");
+            }
+            else {
+                deps.sendJson(res, 400, {
+                    ok: false,
+                    error: `Unsupported action: ${action}`,
+                });
+                return;
+            }
+        }
+        else {
+            // Non-decision triage items
+            if (action === "snooze" && deps.snoozeTriage) {
+                await deps.snoozeTriage(itemId, snoozeDurationMinutes ?? 60);
+                itemStatus = "snoozed";
+                sideEffects.push(`Snoozed for ${snoozeDurationMinutes ?? 60} minutes.`);
+            }
+            else if (action === "dismiss" && deps.dismissTriage) {
+                await deps.dismissTriage(itemId, note ?? undefined);
+                itemStatus = "dismissed";
+                sideEffects.push("Dismissed.");
+            }
+            else if (action === "retry") {
+                itemStatus = "open";
+                sideEffects.push("Retry queued.");
+                continuationPlan = "Will re-attempt the failed operation.";
+            }
+            else {
+                deps.sendJson(res, 400, {
+                    ok: false,
+                    error: `Unsupported action: ${action} for item ${itemId}`,
+                });
+                return;
+            }
+        }
+        const response = {
+            ok: true,
+            itemStatus: itemStatus,
+            continuationPlan,
+            sideEffects,
+        };
+        deps.sendJson(res, 200, response);
+    }, "Perform action on a triage item");
+}