@useorgx/openclaw-plugin 0.4.4 → 0.4.6

package/dist/mcp-http-handler.js

@@ -0,0 +1,395 @@
+import { randomUUID } from "node:crypto";
+const DEFAULT_PROTOCOL_VERSION = "2024-11-05";
+// Domain-scoped MCP servers are meant to be "default safe". The unscoped
+// `/orgx/mcp` endpoint remains available for power users / debugging.
+//
+// NOTE: This scopes only the tools exposed by this plugin (OrgX reporting + mutation).
+// It cannot restrict OpenClaw-native tools (filesystem, shell, etc).
+const ORGX_MCP_ALLOWED_TOOLS_BY_SCOPE = {
+    engineering: [
+        "orgx_status",
+        "orgx_sync",
+        "orgx_emit_activity",
+        "orgx_report_progress",
+        "orgx_register_artifact",
+        "orgx_request_decision",
+        "orgx_spawn_check",
+    ],
+    product: [
+        "orgx_status",
+        "orgx_sync",
+        "orgx_emit_activity",
+        "orgx_report_progress",
+        "orgx_register_artifact",
+        "orgx_request_decision",
+        "orgx_spawn_check",
+    ],
+    design: [
+        "orgx_status",
+        "orgx_sync",
+        "orgx_emit_activity",
+        "orgx_report_progress",
+        "orgx_register_artifact",
+        "orgx_request_decision",
+        "orgx_spawn_check",
+    ],
+    marketing: [
+        "orgx_status",
+        "orgx_sync",
+        "orgx_emit_activity",
+        "orgx_report_progress",
+        "orgx_register_artifact",
+        "orgx_request_decision",
+        "orgx_spawn_check",
+    ],
+    sales: [
+        "orgx_status",
+        "orgx_sync",
+        "orgx_emit_activity",
+        "orgx_report_progress",
+        "orgx_register_artifact",
+        "orgx_request_decision",
+        "orgx_spawn_check",
+    ],
+    operations: [
+        "orgx_status",
+        "orgx_sync",
+        "orgx_emit_activity",
+        "orgx_report_progress",
+        "orgx_register_artifact",
+        "orgx_request_decision",
+        "orgx_spawn_check",
+        // Operations is allowed to do explicit changesets for remediation/runbooks.
+        "orgx_apply_changeset",
+    ],
+    orchestration: [
+        "orgx_status",
+        "orgx_sync",
+        "orgx_emit_activity",
+        "orgx_report_progress",
+        "orgx_register_artifact",
+        "orgx_request_decision",
+        "orgx_spawn_check",
+        // Orchestrator is the primary mutation surface by design.
+        "orgx_apply_changeset",
+    ],
+};
+function isRecord(value) {
+    return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
+function sendJson(res, status, payload) {
+    res.writeHead(status, {
+        "content-type": "application/json; charset=utf-8",
+        "cache-control": "no-store",
+    });
+    res.end(JSON.stringify(payload));
+}
+function sendText(res, status, body) {
+    res.writeHead(status, {
+        "content-type": "text/plain; charset=utf-8",
+        "cache-control": "no-store",
+    });
+    res.end(body);
+}
+function jsonRpcError(id, code, message) {
+    return {
+        jsonrpc: "2.0",
+        id,
+        error: {
+            code,
+            message,
+        },
+    };
+}
+function jsonRpcResult(id, result) {
+    return {
+        jsonrpc: "2.0",
+        id,
+        result,
+    };
+}
+function normalizePath(rawUrl) {
+    const [path] = rawUrl.split("?", 2);
+    return path || "/";
+}
+function parseScopeKey(url) {
+    // Supported paths:
+    // - /orgx/mcp (unscoped)
+    // - /orgx/mcp/<scope> (domain-scoped)
+    if (!url.startsWith("/orgx/mcp/"))
+        return null;
+    const rest = url.slice("/orgx/mcp/".length);
+    const key = rest.split("/", 1)[0]?.trim() ?? "";
+    if (!key)
+        return null;
+    if (!Object.prototype.hasOwnProperty.call(ORGX_MCP_ALLOWED_TOOLS_BY_SCOPE, key))
+        return null;
+    return key;
+}
+function resolveToolScope(scopeKey) {
+    if (!scopeKey)
+        return null;
+    return {
+        key: scopeKey,
+        allowedTools: new Set(ORGX_MCP_ALLOWED_TOOLS_BY_SCOPE[scopeKey]),
+    };
+}
+async function readRequestBodyBuffer(req) {
+    const body = req.body;
+    if (typeof body === "string")
+        return Buffer.from(body, "utf8");
+    if (Buffer.isBuffer(body))
+        return body;
+    if (body instanceof Uint8Array)
+        return Buffer.from(body);
+    if (body instanceof ArrayBuffer)
+        return Buffer.from(body);
+    if (body && typeof body === "object" && !Buffer.isBuffer(body)) {
+        try {
+            return Buffer.from(JSON.stringify(body), "utf8");
+        }
+        catch {
+            return Buffer.from("", "utf8");
+        }
+    }
+    if (typeof req.on !== "function")
+        return Buffer.from("", "utf8");
+    return await new Promise((resolve) => {
+        const chunks = [];
+        const onData = (chunk) => {
+            if (typeof chunk === "string") {
+                chunks.push(Buffer.from(chunk, "utf8"));
+            }
+            else if (Buffer.isBuffer(chunk)) {
+                chunks.push(chunk);
+            }
+            else if (chunk instanceof Uint8Array) {
+                chunks.push(Buffer.from(chunk));
+            }
+        };
+        const onEnd = () => resolve(Buffer.concat(chunks));
+        const onError = () => resolve(Buffer.concat(chunks));
+        req.on?.("data", onData);
+        req.on?.("end", onEnd);
+        req.on?.("error", onError);
+    });
+}
+async function parseJsonBody(req) {
+    const buffer = await readRequestBodyBuffer(req);
+    if (!buffer || buffer.length === 0)
+        return null;
+    try {
+        return JSON.parse(buffer.toString("utf8"));
+    }
+    catch {
+        return null;
+    }
+}
+function pickId(value) {
+    if (typeof value === "string")
+        return value;
+    if (typeof value === "number" && Number.isFinite(value))
+        return value;
+    if (value === null)
+        return null;
+    return null;
+}
+function normalizeToolArguments(value) {
+    if (isRecord(value))
+        return value;
+    return {};
+}
+function buildToolsList(tools) {
+    const entries = Array.from(tools.values())
+        .map((tool) => ({
+        name: tool.name,
+        description: tool.description,
+        inputSchema: tool.parameters,
+    }))
+        .sort((a, b) => String(a.name).localeCompare(String(b.name)));
+    return entries;
+}
+async function handleRpcMessage(input) {
+    const msg = input.message;
+    if (!isRecord(msg)) {
+        return jsonRpcError(null, -32600, "Invalid Request");
+    }
+    const id = pickId(msg.id);
+    const method = typeof msg.method === "string" ? msg.method.trim() : "";
+    if (!method) {
+        return jsonRpcError(id, -32600, "Invalid Request");
+    }
+    const params = isRecord(msg.params) ? msg.params : {};
+    // Notifications do not receive a response.
+    if (id === null && method.startsWith("notifications/")) {
+        return null;
+    }
+    if (method === "initialize") {
+        const requestedProtocol = typeof params.protocolVersion === "string" ? params.protocolVersion : null;
+        const protocolVersion = requestedProtocol?.trim() || DEFAULT_PROTOCOL_VERSION;
+        const scopedServerName = input.toolScope ? `${input.serverName}/${input.toolScope.key}` : input.serverName;
+        return jsonRpcResult(id, {
+            protocolVersion,
+            capabilities: {
+                tools: {},
+                prompts: {},
+            },
+            serverInfo: {
+                name: scopedServerName,
+                version: input.serverVersion,
+            },
+        });
+    }
+    if (method === "ping") {
+        return jsonRpcResult(id, { ok: true });
+    }
+    if (method === "tools/list") {
+        if (input.toolScope) {
+            const scopedTools = new Map();
+            for (const name of input.toolScope.allowedTools) {
+                const tool = input.tools.get(name);
+                if (tool)
+                    scopedTools.set(name, tool);
+            }
+            return jsonRpcResult(id, { tools: buildToolsList(scopedTools) });
+        }
+        return jsonRpcResult(id, {
+            tools: buildToolsList(input.tools),
+        });
+    }
+    if (method === "tools/call") {
+        const toolName = typeof params.name === "string" ? params.name.trim() : "";
+        if (!toolName) {
+            return jsonRpcError(id, -32602, "Missing tool name");
+        }
+        if (input.toolScope && !input.toolScope.allowedTools.has(toolName)) {
+            return jsonRpcError(id, -32601, `Tool not available in scope '${input.toolScope.key}': ${toolName}`);
+        }
+        const tool = input.tools.get(toolName) ?? null;
+        if (!tool) {
+            return jsonRpcError(id, -32601, `Tool not found: ${toolName}`);
+        }
+        const args = normalizeToolArguments(params.arguments);
+        try {
+            const callId = `mcp-${id ?? randomUUID()}`;
+            const result = await tool.execute(callId, args);
+            return jsonRpcResult(id, {
+                content: Array.isArray(result?.content) ? result.content : [],
+                isError: result?.isError === true,
+            });
+        }
+        catch (err) {
+            input.logger.warn?.("[orgx] Local MCP tool call failed", {
+                tool: toolName,
+                error: err instanceof Error ? err.message : String(err),
+            });
+            return jsonRpcResult(id, {
+                content: [
+                    {
+                        type: "text",
+                        text: `❌ Tool execution failed: ${err instanceof Error ? err.message : String(err)}`,
+                    },
+                ],
+                isError: true,
+            });
+        }
+    }
+    if (method === "resources/list") {
+        return jsonRpcResult(id, { resources: [] });
+    }
+    if (method === "prompts/list") {
+        const prompts = Array.from(input.prompts.values())
+            .sort((a, b) => a.name.localeCompare(b.name))
+            .map((prompt) => ({
+            name: prompt.name,
+            description: prompt.description ?? "",
+            arguments: Array.isArray(prompt.arguments) ? prompt.arguments : [],
+        }));
+        return jsonRpcResult(id, { prompts });
+    }
+    if (method === "prompts/get") {
+        const promptName = typeof params.name === "string" ? params.name.trim() : "";
+        if (!promptName) {
+            return jsonRpcError(id, -32602, "Missing prompt name");
+        }
+        const prompt = input.prompts.get(promptName) ?? null;
+        if (!prompt) {
+            return jsonRpcError(id, -32601, `Prompt not found: ${promptName}`);
+        }
+        return jsonRpcResult(id, {
+            description: prompt.description ?? "",
+            messages: prompt.messages,
+        });
+    }
+    if (method.startsWith("notifications/")) {
+        return null;
+    }
+    return jsonRpcError(id, -32601, `Method not found: ${method}`);
+}
+export function createMcpHttpHandler(input) {
+    const logger = input.logger ?? {};
+    const prompts = input.prompts ?? new Map();
+    return async function handler(req, res) {
+        const method = (req.method ?? "GET").toUpperCase();
+        const rawUrl = req.url ?? "/";
+        const url = normalizePath(rawUrl);
+        if (!(url === "/orgx/mcp" || url.startsWith("/orgx/mcp/"))) {
+            return false;
+        }
+        const scopeKey = parseScopeKey(url);
+        const toolScope = resolveToolScope(scopeKey);
+        if (url.startsWith("/orgx/mcp/") && !scopeKey) {
+            sendText(res, 404, `Unknown OrgX MCP scope. Supported: ${Object.keys(ORGX_MCP_ALLOWED_TOOLS_BY_SCOPE).join(", ")}\n`);
+            return true;
+        }
+        if (method === "OPTIONS") {
+            res.writeHead(204, {
+                "cache-control": "no-store",
+            });
+            res.end();
+            return true;
+        }
+        if (method === "GET") {
+            const suffix = toolScope ? ` (scope: ${toolScope.key})` : "";
+            sendText(res, 200, `OrgX Local MCP bridge is running${suffix}.\n`);
+            return true;
+        }
+        if (method !== "POST") {
+            sendJson(res, 405, {
+                error: "Use POST /orgx/mcp",
+            });
+            return true;
+        }
+        const payload = await parseJsonBody(req);
+        if (!payload) {
+            sendJson(res, 400, {
+                error: "Invalid JSON body",
+            });
+            return true;
+        }
+        const messages = Array.isArray(payload) ? payload : [payload];
+        const responses = [];
+        for (const message of messages) {
+            const response = await handleRpcMessage({
+                message,
+                tools: input.tools,
+                prompts,
+                logger,
+                serverName: input.serverName,
+                serverVersion: input.serverVersion,
+                toolScope,
+            });
+            if (response)
+                responses.push(response);
+        }
+        if (responses.length === 0) {
+            res.writeHead(204, {
+                "cache-control": "no-store",
+            });
+            res.end();
+            return true;
+        }
+        sendJson(res, 200, Array.isArray(payload) ? responses : responses[0]);
+        return true;
+    };
+}

package/dist/next-up-queue-store.d.ts

@@ -0,0 +1,31 @@
+export type NextUpPinnedEntry = {
+    initiativeId: string;
+    workstreamId: string;
+    preferredTaskId: string | null;
+    preferredMilestoneId: string | null;
+    createdAt: string;
+    updatedAt: string;
+};
+type PersistedNextUpQueue = {
+    version: 1;
+    updatedAt: string;
+    pins: NextUpPinnedEntry[];
+};
+export declare function readNextUpQueuePins(): PersistedNextUpQueue;
+export declare function upsertNextUpQueuePin(input: {
+    initiativeId: string;
+    workstreamId: string;
+    preferredTaskId?: string | null;
+    preferredMilestoneId?: string | null;
+}): PersistedNextUpQueue;
+export declare function removeNextUpQueuePin(input: {
+    initiativeId: string;
+    workstreamId: string;
+}): PersistedNextUpQueue;
+export declare function setNextUpQueuePinOrder(input: {
+    order: Array<{
+        initiativeId: string;
+        workstreamId: string;
+    }>;
+}): PersistedNextUpQueue;
+export {};

package/dist/next-up-queue-store.js

@@ -0,0 +1,169 @@
+import { chmodSync, existsSync, mkdirSync, readFileSync, } from "node:fs";
+import { getOrgxPluginConfigDir, getOrgxPluginConfigPath } from "./paths.js";
+import { backupCorruptFileSync, writeJsonFileAtomicSync } from "./fs-utils.js";
+const MAX_PINS = 240;
+function storeDir() {
+    return getOrgxPluginConfigDir();
+}
+function storeFile() {
+    return getOrgxPluginConfigPath("next-up-queue.json");
+}
+function ensureStoreDir() {
+    const dir = storeDir();
+    mkdirSync(dir, { recursive: true, mode: 0o700 });
+    try {
+        chmodSync(dir, 0o700);
+    }
+    catch {
+        // best effort
+    }
+}
+function parseJson(value) {
+    try {
+        return JSON.parse(value);
+    }
+    catch {
+        return null;
+    }
+}
+function normalizeNullableString(value) {
+    if (typeof value !== "string")
+        return null;
+    const trimmed = value.trim();
+    return trimmed.length > 0 ? trimmed : null;
+}
+function normalizeEntry(input) {
+    return {
+        initiativeId: input.initiativeId.trim(),
+        workstreamId: input.workstreamId.trim(),
+        preferredTaskId: normalizeNullableString(input.preferredTaskId),
+        preferredMilestoneId: normalizeNullableString(input.preferredMilestoneId),
+        createdAt: input.createdAt,
+        updatedAt: input.updatedAt,
+    };
+}
+export function readNextUpQueuePins() {
+    const file = storeFile();
+    try {
+        if (!existsSync(file)) {
+            return { version: 1, updatedAt: new Date().toISOString(), pins: [] };
+        }
+        const raw = readFileSync(file, "utf8");
+        const parsed = parseJson(raw);
+        if (!parsed || typeof parsed !== "object") {
+            backupCorruptFileSync(file);
+            return { version: 1, updatedAt: new Date().toISOString(), pins: [] };
+        }
+        const pins = Array.isArray(parsed.pins) ? parsed.pins : [];
+        return {
+            version: 1,
+            updatedAt: typeof parsed.updatedAt === "string"
+                ? parsed.updatedAt
+                : new Date().toISOString(),
+            pins: pins
+                .filter((entry) => Boolean(entry && typeof entry === "object"))
+                .map((entry) => normalizeEntry(entry)),
+        };
+    }
+    catch {
+        return { version: 1, updatedAt: new Date().toISOString(), pins: [] };
+    }
+}
+export function upsertNextUpQueuePin(input) {
+    const initiativeId = input.initiativeId.trim();
+    const workstreamId = input.workstreamId.trim();
+    if (!initiativeId || !workstreamId) {
+        return readNextUpQueuePins();
+    }
+    ensureStoreDir();
+    const now = new Date().toISOString();
+    const next = readNextUpQueuePins();
+    const key = `${initiativeId}:${workstreamId}`;
+    const existing = next.pins.find((pin) => `${pin.initiativeId}:${pin.workstreamId}` === key);
+    const updated = normalizeEntry({
+        initiativeId,
+        workstreamId,
+        preferredTaskId: input.preferredTaskId ?? existing?.preferredTaskId ?? null,
+        preferredMilestoneId: input.preferredMilestoneId ?? existing?.preferredMilestoneId ?? null,
+        createdAt: existing?.createdAt ?? now,
+        updatedAt: now,
+    });
+    next.pins = [updated, ...next.pins.filter((pin) => `${pin.initiativeId}:${pin.workstreamId}` !== key)].slice(0, MAX_PINS);
+    next.updatedAt = now;
+    try {
+        writeJsonFileAtomicSync(storeFile(), next, 0o600);
+    }
+    catch {
+        // best effort
+    }
+    return next;
+}
+export function removeNextUpQueuePin(input) {
+    const initiativeId = input.initiativeId.trim();
+    const workstreamId = input.workstreamId.trim();
+    if (!initiativeId || !workstreamId) {
+        return readNextUpQueuePins();
+    }
+    ensureStoreDir();
+    const next = readNextUpQueuePins();
+    const key = `${initiativeId}:${workstreamId}`;
+    const filtered = next.pins.filter((pin) => `${pin.initiativeId}:${pin.workstreamId}` !== key);
+    if (filtered.length === next.pins.length)
+        return next;
+    next.pins = filtered;
+    next.updatedAt = new Date().toISOString();
+    try {
+        writeJsonFileAtomicSync(storeFile(), next, 0o600);
+    }
+    catch {
+        // best effort
+    }
+    return next;
+}
+export function setNextUpQueuePinOrder(input) {
+    ensureStoreDir();
+    const next = readNextUpQueuePins();
+    const now = new Date().toISOString();
+    const byKey = new Map(next.pins.map((pin) => [`${pin.initiativeId}:${pin.workstreamId}`, pin]));
+    const ordered = [];
+    const seen = new Set();
+    for (const entry of input.order) {
+        const initiativeId = (entry.initiativeId ?? "").trim();
+        const workstreamId = (entry.workstreamId ?? "").trim();
+        if (!initiativeId || !workstreamId)
+            continue;
+        const key = `${initiativeId}:${workstreamId}`;
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        const pin = byKey.get(key);
+        if (pin) {
+            ordered.push(pin);
+        }
+        else {
+            ordered.push({
+                initiativeId,
+                workstreamId,
+                preferredTaskId: null,
+                preferredMilestoneId: null,
+                createdAt: now,
+                updatedAt: now,
+            });
+        }
+    }
+    for (const pin of next.pins) {
+        const key = `${pin.initiativeId}:${pin.workstreamId}`;
+        if (seen.has(key))
+            continue;
+        ordered.push(pin);
+    }
+    next.pins = ordered.slice(0, MAX_PINS);
+    next.updatedAt = now;
+    try {
+        writeJsonFileAtomicSync(storeFile(), next, 0o600);
+    }
+    catch {
+        // best effort
+    }
+    return next;
+}

package/dist/openclaw.plugin.json

@@ -1,7 +1,7 @@
 {
   "id": "orgx",
   "name": "OrgX Integration",
-  "version": "1.0.1",
+  "version": "1.0.2",
   "description": "Connects Clawdbot to OrgX for agent orchestration, quality gates, and model routing",
   "entry": "./index.js",
   "author": "OrgX Team",

package/dist/outbox.d.ts

@@ -6,7 +6,7 @@
 import type { LiveActivityItem } from "./types.js";
 export interface OutboxEvent {
     id: string;
-    type: "progress" | "decision" | "artifact" | "changeset";
+    type: "progress" | "decision" | "artifact" | "changeset" | "retro" | "outcome";
     timestamp: string;
     payload: Record<string, unknown>;
     /** Converted to a LiveActivityItem for dashboard display. */

package/dist/runtime-instance-store.d.ts

@@ -21,7 +21,7 @@ export type RuntimeInstanceRecord = {
     id: string;
     sourceClient: RuntimeSourceClient;
     displayName: string;
-    providerLogo: "openai" | "anthropic" | "openclaw" | "orgx" | "unknown";
+    providerLogo: "codex" | "openai" | "anthropic" | "openclaw" | "orgx" | "unknown";
     state: RuntimeInstanceState;
     event: RuntimeHookEvent;
     runId: string | null;

package/dist/runtime-instance-store.js

@@ -85,7 +85,7 @@ function normalizeHookEvent(value) {
 }
 function toProviderLogo(sourceClient) {
     if (sourceClient === "codex")
-        return "openai";
+        return "codex";
     if (sourceClient === "claude-code")
         return "anthropic";
     if (sourceClient === "openclaw")
@@ -94,6 +94,22 @@ function toProviderLogo(sourceClient) {
         return "orgx";
     return "unknown";
 }
+function normalizeProviderLogo(value, sourceClient) {
+    const normalized = normalizeNullableString(value)?.toLowerCase();
+    if (normalized === "codex")
+        return "codex";
+    if (normalized === "openai")
+        return sourceClient === "codex" ? "codex" : "openai";
+    if (normalized === "anthropic")
+        return "anthropic";
+    if (normalized === "openclaw")
+        return "openclaw";
+    if (normalized === "orgx")
+        return "orgx";
+    if (normalized === "unknown")
+        return "unknown";
+    return toProviderLogo(sourceClient);
+}
 function toDisplayName(sourceClient) {
     if (sourceClient === "codex")
         return "Codex";
@@ -152,11 +168,12 @@ function normalizeProgress(value) {
     return Math.max(0, Math.min(100, Math.round(value)));
 }
 function normalizeRecord(input) {
+    const sourceClient = normalizeSourceClient(input.sourceClient);
     return {
         id: normalizeNullableString(input.id) ?? input.id,
-        sourceClient: normalizeSourceClient(input.sourceClient),
+        sourceClient,
         displayName: normalizeNullableString(input.displayName) ?? "Runtime",
-        providerLogo: input.providerLogo,
+        providerLogo: normalizeProviderLogo(input.providerLogo, sourceClient),
         state: normalizeState(input.state),
         event: normalizeHookEvent(input.event),
         runId: normalizeNullableString(input.runId),