@useorgx/openclaw-plugin 0.4.3 → 0.4.5

package/dist/mcp-client-setup.js

@@ -0,0 +1,215 @@
+import { existsSync, readFileSync, statSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { randomUUID } from "node:crypto";
+import { writeFileAtomicSync, writeJsonFileAtomicSync } from "./fs-utils.js";
+function isRecord(value) {
+    return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
+function parseJsonObjectSafe(raw) {
+    try {
+        const parsed = JSON.parse(raw);
+        return isRecord(parsed) ? parsed : null;
+    }
+    catch {
+        return null;
+    }
+}
+function fileModeOrDefault(path, fallback) {
+    try {
+        const stat = statSync(path);
+        return stat.mode & 0o777;
+    }
+    catch {
+        return fallback;
+    }
+}
+function backupPath(path) {
+    return `${path}.bak.${Date.now()}-${randomUUID().slice(0, 8)}`;
+}
+function backupFileSync(path, mode) {
+    try {
+        const content = readFileSync(path);
+        const next = backupPath(path);
+        writeFileAtomicSync(next, content.toString("utf8"), { mode, encoding: "utf8" });
+        return next;
+    }
+    catch {
+        return null;
+    }
+}
+export function patchClaudeMcpConfig(input) {
+    const currentServers = isRecord(input.current.mcpServers) ? input.current.mcpServers : {};
+    const currentOrgx = isRecord(currentServers.orgx) ? currentServers.orgx : {};
+    const priorUrl = typeof currentOrgx.url === "string" ? currentOrgx.url : "";
+    const priorType = typeof currentOrgx.type === "string" ? currentOrgx.type : "";
+    const nextOrgx = {
+        ...currentOrgx,
+        type: "http",
+        url: input.localMcpUrl,
+        description: typeof currentOrgx.description === "string" && currentOrgx.description.trim().length > 0
+            ? currentOrgx.description
+            : "OrgX platform via local OpenClaw plugin (no OAuth)",
+    };
+    const nextServers = {
+        ...currentServers,
+        orgx: nextOrgx,
+    };
+    const next = {
+        ...input.current,
+        mcpServers: nextServers,
+    };
+    const updated = priorUrl !== input.localMcpUrl || priorType !== "http";
+    return { updated, next };
+}
+export function patchCursorMcpConfig(input) {
+    const currentServers = isRecord(input.current.mcpServers) ? input.current.mcpServers : {};
+    const key = "orgx-openclaw";
+    const existing = isRecord(currentServers[key]) ? currentServers[key] : {};
+    const priorUrl = typeof existing.url === "string" ? existing.url : "";
+    const nextEntry = {
+        ...existing,
+        url: input.localMcpUrl,
+    };
+    const nextServers = {
+        ...currentServers,
+        [key]: nextEntry,
+    };
+    const next = {
+        ...input.current,
+        mcpServers: nextServers,
+    };
+    const updated = priorUrl !== input.localMcpUrl;
+    return { updated, next };
+}
+export function patchCodexConfigToml(input) {
+    const lines = input.current.split(/\r?\n/);
+    const headerRegex = /^\[mcp_servers\.(?:orgx|"orgx")\]\s*$/;
+    let headerIndex = -1;
+    for (let i = 0; i < lines.length; i += 1) {
+        if (headerRegex.test(lines[i].trim())) {
+            headerIndex = i;
+            break;
+        }
+    }
+    const urlLine = `url = "${input.localMcpUrl}"`;
+    if (headerIndex === -1) {
+        const suffix = [
+            "",
+            "[mcp_servers.orgx]",
+            urlLine,
+            "",
+        ].join("\n");
+        const normalized = input.current.endsWith("\n") ? input.current : `${input.current}\n`;
+        return { updated: true, next: `${normalized}${suffix}` };
+    }
+    let sectionEnd = lines.length;
+    for (let i = headerIndex + 1; i < lines.length; i += 1) {
+        if (lines[i].trim().startsWith("[")) {
+            sectionEnd = i;
+            break;
+        }
+    }
+    let updated = false;
+    let urlIndex = -1;
+    for (let i = headerIndex + 1; i < sectionEnd; i += 1) {
+        if (/^\s*url\s*=/.test(lines[i])) {
+            urlIndex = i;
+            break;
+        }
+    }
+    if (urlIndex >= 0) {
+        if (lines[urlIndex].trim() !== urlLine) {
+            lines[urlIndex] = urlLine;
+            updated = true;
+        }
+    }
+    else {
+        lines.splice(headerIndex + 1, 0, urlLine);
+        updated = true;
+    }
+    return { updated, next: `${lines.join("\n")}\n` };
+}
+export async function autoConfigureDetectedMcpClients(input) {
+    const logger = input.logger ?? {};
+    const home = input.homeDir ?? homedir();
+    const updatedPaths = [];
+    const skippedPaths = [];
+    const targets = [
+        { kind: "claude", path: join(home, ".claude", "mcp.json") },
+        { kind: "cursor", path: join(home, ".cursor", "mcp.json") },
+        { kind: "codex", path: join(home, ".codex", "config.toml") },
+    ];
+    for (const target of targets) {
+        if (!existsSync(target.path)) {
+            skippedPaths.push(target.path);
+            continue;
+        }
+        const mode = fileModeOrDefault(target.path, 0o600);
+        try {
+            if (target.kind === "codex") {
+                const current = readFileSync(target.path, "utf8");
+                const patched = patchCodexConfigToml({ current, localMcpUrl: input.localMcpUrl });
+                if (!patched.updated) {
+                    skippedPaths.push(target.path);
+                    continue;
+                }
+                const backup = backupFileSync(target.path, mode);
+                if (!backup) {
+                    logger.warn?.("[orgx] MCP client autoconfig: backup failed; skipping", {
+                        path: target.path,
+                        kind: target.kind,
+                    });
+                    skippedPaths.push(target.path);
+                    continue;
+                }
+                writeFileAtomicSync(target.path, patched.next, { mode, encoding: "utf8" });
+                updatedPaths.push(target.path);
+                continue;
+            }
+            const currentText = readFileSync(target.path, "utf8");
+            const current = parseJsonObjectSafe(currentText);
+            if (!current) {
+                logger.warn?.("[orgx] MCP client autoconfig: invalid JSON; skipping", {
+                    path: target.path,
+                    kind: target.kind,
+                });
+                skippedPaths.push(target.path);
+                continue;
+            }
+            const patched = target.kind === "claude"
+                ? patchClaudeMcpConfig({ current, localMcpUrl: input.localMcpUrl })
+                : patchCursorMcpConfig({ current, localMcpUrl: input.localMcpUrl });
+            if (!patched.updated) {
+                skippedPaths.push(target.path);
+                continue;
+            }
+            const backup = backupFileSync(target.path, mode);
+            if (!backup) {
+                logger.warn?.("[orgx] MCP client autoconfig: backup failed; skipping", {
+                    path: target.path,
+                    kind: target.kind,
+                });
+                skippedPaths.push(target.path);
+                continue;
+            }
+            writeJsonFileAtomicSync(target.path, patched.next, mode);
+            updatedPaths.push(target.path);
+        }
+        catch (err) {
+            logger.warn?.("[orgx] MCP client autoconfig failed; leaving backup in place", {
+                path: target.path,
+                kind: target.kind,
+                error: err instanceof Error ? err.message : String(err),
+            });
+            skippedPaths.push(target.path);
+        }
+    }
+    if (updatedPaths.length > 0) {
+        logger.info?.("[orgx] MCP client autoconfig applied", {
+            localMcpUrl: input.localMcpUrl,
+            updated: updatedPaths,
+        });
+    }
+    return { updatedPaths, skippedPaths };
+}

package/dist/mcp-http-handler.d.ts

@@ -0,0 +1,38 @@
+export type Logger = {
+    info?: (message: string, meta?: Record<string, unknown>) => void;
+    warn?: (message: string, meta?: Record<string, unknown>) => void;
+    debug?: (message: string, meta?: Record<string, unknown>) => void;
+};
+export interface PluginRequest {
+    method?: string;
+    url?: string;
+    headers: Record<string, string | string[] | undefined>;
+    body?: unknown;
+    on?: (event: string, listener: (...args: unknown[]) => void) => void;
+    once?: (event: string, listener: (...args: unknown[]) => void) => void;
+}
+export interface PluginResponse {
+    writeHead(status: number, headers?: Record<string, string>): void;
+    end(body?: string | Buffer): void;
+    write?(chunk: string | Buffer): boolean | void;
+    writableEnded?: boolean;
+}
+export type ToolResult = {
+    content: Array<{
+        type: "text";
+        text: string;
+    }>;
+    isError?: boolean;
+};
+export type RegisteredTool = {
+    name: string;
+    description: string;
+    parameters: Record<string, unknown>;
+    execute: (callId: string, params?: unknown) => Promise<ToolResult>;
+};
+export declare function createMcpHttpHandler(input: {
+    tools: Map<string, RegisteredTool>;
+    logger?: Logger;
+    serverName: string;
+    serverVersion: string;
+}): (req: PluginRequest, res: PluginResponse) => Promise<boolean>;

package/dist/mcp-http-handler.js

@@ -0,0 +1,254 @@
+import { randomUUID } from "node:crypto";
+const DEFAULT_PROTOCOL_VERSION = "2024-11-05";
+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 || "/";
+}
+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;
+        return jsonRpcResult(id, {
+            protocolVersion,
+            capabilities: {
+                tools: {},
+            },
+            serverInfo: {
+                name: input.serverName,
+                version: input.serverVersion,
+            },
+        });
+    }
+    if (method === "ping") {
+        return jsonRpcResult(id, { ok: true });
+    }
+    if (method === "tools/list") {
+        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");
+        }
+        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") {
+        return jsonRpcResult(id, { prompts: [] });
+    }
+    if (method.startsWith("notifications/")) {
+        return null;
+    }
+    return jsonRpcError(id, -32601, `Method not found: ${method}`);
+}
+export function createMcpHttpHandler(input) {
+    const logger = input.logger ?? {};
+    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;
+        }
+        if (method === "OPTIONS") {
+            res.writeHead(204, {
+                "cache-control": "no-store",
+            });
+            res.end();
+            return true;
+        }
+        if (method === "GET") {
+            sendText(res, 200, "OrgX Local MCP bridge is running.\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,
+                logger,
+                serverName: input.serverName,
+                serverVersion: input.serverVersion,
+            });
+            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/telemetry/posthog.d.ts

@@ -0,0 +1,8 @@
+export declare function isOrgxTelemetryDisabled(): boolean;
+export declare function resolvePosthogApiKey(): string | null;
+export declare function resolvePosthogHost(): string;
+export declare function posthogCapture(input: {
+    event: string;
+    distinctId: string;
+    properties?: Record<string, unknown>;
+}): Promise<void>;

package/dist/telemetry/posthog.js

@@ -0,0 +1,81 @@
+const POSTHOG_DEFAULT_API_KEY = "phc_s4KPgkYEFZgvkMYw4zXG41H5FN6haVwbEWPYHfNjxOc";
+const POSTHOG_DEFAULT_HOST = "https://us.i.posthog.com";
+function isTruthyEnv(value) {
+    if (!value)
+        return false;
+    switch (value.trim().toLowerCase()) {
+        case "1":
+        case "true":
+        case "yes":
+        case "y":
+        case "on":
+            return true;
+        default:
+            return false;
+    }
+}
+export function isOrgxTelemetryDisabled() {
+    return (isTruthyEnv(process.env.ORGX_TELEMETRY_DISABLED) ||
+        isTruthyEnv(process.env.OPENCLAW_TELEMETRY_DISABLED) ||
+        isTruthyEnv(process.env.POSTHOG_DISABLED));
+}
+export function resolvePosthogApiKey() {
+    const fromEnv = process.env.ORGX_POSTHOG_API_KEY ??
+        process.env.POSTHOG_API_KEY ??
+        process.env.ORGX_POSTHOG_KEY ??
+        process.env.POSTHOG_KEY ??
+        "";
+    const trimmed = fromEnv.trim();
+    if (trimmed)
+        return trimmed;
+    return POSTHOG_DEFAULT_API_KEY;
+}
+export function resolvePosthogHost() {
+    const fromEnv = process.env.ORGX_POSTHOG_HOST ??
+        process.env.POSTHOG_HOST ??
+        process.env.ORGX_POSTHOG_API_HOST ??
+        process.env.POSTHOG_API_HOST ??
+        "";
+    const trimmed = fromEnv.trim();
+    return trimmed || POSTHOG_DEFAULT_HOST;
+}
+function toPosthogBatchUrl(host) {
+    try {
+        return new URL("/batch/", host).toString();
+    }
+    catch {
+        return `${POSTHOG_DEFAULT_HOST}/batch/`;
+    }
+}
+export async function posthogCapture(input) {
+    if (isOrgxTelemetryDisabled())
+        return;
+    const apiKey = resolvePosthogApiKey();
+    if (!apiKey)
+        return;
+    const url = toPosthogBatchUrl(resolvePosthogHost());
+    const now = new Date().toISOString();
+    const body = {
+        api_key: apiKey,
+        batch: [
+            {
+                type: "capture",
+                event: input.event,
+                distinct_id: input.distinctId,
+                properties: {
+                    $lib: "orgx-openclaw-plugin",
+                    ...(input.properties ?? {}),
+                },
+                timestamp: now,
+            },
+        ],
+        sent_at: now,
+    };
+    await fetch(url, {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json",
+        },
+        body: JSON.stringify(body),
+    }).then(() => undefined);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@useorgx/openclaw-plugin",
-  "version": "0.4.3",
+  "version": "0.4.5",
   "description": "OrgX plugin for OpenClaw — agent orchestration, quality gates, model routing, and live dashboard",
   "type": "module",
   "main": "./dist/index.js",