@useorgx/openclaw-plugin 0.4.9 → 0.7.2

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,154 @@
+import { exec } from "node:child_process";
+import { existsSync } 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("'", "'\\''")}'`;
+}
+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;
+}
+export function registerLiveTerminalRoutes(router, deps) {
+    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,192 @@
+/**
+ * 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;
+        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. 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");
+}

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

@@ -9,7 +9,9 @@ type AutoContinueRunRecord = Record<string, any> & {
 };
 type NextUpQueue = {
     items: Array<{
+        initiativeId: string;
         workstreamId: string;
+        queueState: "queued" | "running" | "blocked" | "idle";
         runnerAgentId?: string | null;
         runnerAgentName?: string | null;
         runnerSource?: string | null;
@@ -17,6 +19,23 @@ type NextUpQueue = {
         workstreamTitle?: string | null;
         nextTaskId?: string | null;
         nextTaskTitle?: string | null;
+        sliceScope?: "task" | "milestone" | "workstream" | null;
+        sliceTaskIds?: string[];
+        sliceTaskCount?: number | null;
+        sliceMilestoneId?: string | null;
+        executionPolicy?: {
+            domain?: string;
+            requiredSkills?: string[];
+            profile?: string | null;
+            sliceScopePreference?: "adaptive" | "task" | "milestone" | "workstream" | null;
+            maxSliceTasks?: number | null;
+            maxParallelAgents?: number | null;
+            dependencyMode?: "strict" | "relaxed" | null;
+        } | null;
+        autoContinue?: {
+            status?: string | null;
+            stopReason?: string | null;
+        } | null;
     }>;
     degraded: string[];
 };
@@ -29,7 +48,7 @@ type RegisterMissionControlActionsRoutesDeps<TReq, TRes> = {
     dedupeStrings: (values: string[]) => string[];
     resolveAgentDisplayName: (agentId: string, fallbackName: string | null) => Promise<string | null>;
     buildNextUpQueue: (input: {
-        initiativeId: string;
+        initiativeId?: string | null;
     }) => Promise<NextUpQueue>;
     startAutoContinueRun: (input: any) => Promise<AutoContinueRunRecord>;
     autoContinueRuns: Map<string, any>;
@@ -49,6 +68,24 @@ type RegisterMissionControlActionsRoutesDeps<TReq, TRes> = {
     stopAutoContinueRun: (input: any) => Promise<void>;
     updateInitiativeAutoContinueState: (input: any) => Promise<void>;
     tickAllAutoContinue: () => Promise<void>;
+    scheduleAutoFixForWorkstream: (input: {
+        initiativeId: string;
+        workstreamId: string;
+        runId?: string | null;
+        event?: string | null;
+        requestedByAgentId?: string | null;
+        requestedByAgentName?: string | null;
+        graceMs?: number | null;
+    }) => Promise<{
+        requestId: string;
+        initiativeId: string;
+        workstreamId: string;
+        runId: string | null;
+        sourceEvent: string | null;
+        graceMs: number;
+        scheduledAt: string;
+        dueAt: string;
+    }>;
     upsertNextUpQueuePin: (input: {
         initiativeId: string;
         workstreamId: string;
@@ -65,6 +102,13 @@ type RegisterMissionControlActionsRoutesDeps<TReq, TRes> = {
         pins: unknown[];
         updatedAt: string;
     };
+    suppressNextUpQueueItem: (input: {
+        initiativeId: string;
+        workstreamId: string;
+    }) => {
+        suppressions: unknown[];
+        updatedAt: string;
+    };
     setNextUpQueuePinOrder: (input: {
         order: Array<{
             initiativeId: string;
@@ -74,8 +118,12 @@ type RegisterMissionControlActionsRoutesDeps<TReq, TRes> = {
         pins: unknown[];
         updatedAt: string;
     };
+    clearNextUpQueueCache: (initiativeId?: string | null) => void;
     resolveAutoAssignments: (input: any) => Promise<unknown>;
+    buildMissionControlGraph: (initiativeId: string) => Promise<unknown>;
+    applyLocalInitiativeOverrideToGraph: (graph: unknown) => unknown;
     client: any;
+    rawRequest?: (requestMethod: "GET" | "POST" | "PATCH" | "PUT" | "DELETE", requestPath: string, body?: unknown) => Promise<unknown>;
     sendJson: (res: TRes, status: number, payload: unknown) => void;
     safeErrorMessage: (err: unknown) => string;
 };