@useorgx/openclaw-plugin 0.4.8 → 0.7.0

package/dist/entities/auto-assignment.js

@@ -0,0 +1,141 @@
+import { callLlmJson } from "../http/helpers/llm-client.js";
+const VALID_DOMAINS = new Set([
+    "engineering",
+    "product",
+    "design",
+    "marketing",
+    "sales",
+    "operations",
+]);
+function heuristicDomainGuess(title, summary) {
+    const haystack = `${title} ${summary ?? ""}`.toLowerCase();
+    if (/market|campaign|thread|article|tweet|copy/.test(haystack))
+        return ["marketing"];
+    if (/design|ux|ui|a11y/.test(haystack))
+        return ["design"];
+    if (/ops|runbook|incident|reliability/.test(haystack))
+        return ["operations"];
+    if (/sales|deal|pipeline/.test(haystack))
+        return ["sales"];
+    return ["engineering", "product"];
+}
+export async function autoAssignEntityForCreate(input) {
+    const warnings = [];
+    const byKey = new Map();
+    const addAgent = (agent) => {
+        const key = `${agent.id}:${agent.name}`.toLowerCase();
+        if (!byKey.has(key))
+            byKey.set(key, agent);
+    };
+    let liveAgents = [];
+    try {
+        const agentResp = await input.client.getLiveAgents({
+            initiative: input.initiativeId,
+            includeIdle: true,
+        });
+        liveAgents = (Array.isArray(agentResp.agents) ? agentResp.agents : [])
+            .map((raw) => {
+            if (!raw || typeof raw !== "object")
+                return null;
+            const record = raw;
+            const id = (typeof record.id === "string" && record.id.trim()) ||
+                (typeof record.agentId === "string" && record.agentId.trim()) ||
+                "";
+            const name = (typeof record.name === "string" && record.name.trim()) ||
+                (typeof record.agentName === "string" && record.agentName.trim()) ||
+                id;
+            if (!name)
+                return null;
+            return {
+                id: id || `name:${name}`,
+                name,
+                domain: (typeof record.domain === "string" && record.domain.trim()) ||
+                    (typeof record.role === "string" && record.role.trim()) ||
+                    null,
+                status: (typeof record.status === "string" && record.status.trim()) || null,
+            };
+        })
+            .filter((agent) => agent !== null);
+    }
+    catch (err) {
+        warnings.push(`live agents unavailable (${input.toErrorMessage(err)})`);
+    }
+    const orchestrator = liveAgents.find((agent) => /holt|orchestrator/i.test(agent.name) ||
+        /orchestrator/i.test(agent.domain ?? ""));
+    if (orchestrator)
+        addAgent(orchestrator);
+    let assignmentSource = "fallback";
+    try {
+        const preflight = await input.client.delegationPreflight({
+            intent: `${input.title}${input.summary ? `: ${input.summary}` : ""}`,
+        });
+        const recommendations = preflight.data?.recommended_split ?? [];
+        const recommendedDomains = [
+            ...new Set(recommendations
+                .map((entry) => String(entry.owner_domain ?? "").trim().toLowerCase())
+                .filter(Boolean)),
+        ];
+        for (const domain of recommendedDomains) {
+            const match = liveAgents.find((agent) => (agent.domain ?? "").toLowerCase().includes(domain));
+            if (match)
+                addAgent(match);
+        }
+        if (recommendedDomains.length > 0) {
+            assignmentSource = "orchestrator";
+        }
+    }
+    catch (err) {
+        warnings.push(`delegation preflight failed (${input.toErrorMessage(err)})`);
+    }
+    if (byKey.size === 0) {
+        const domainResult = await callLlmJson({
+            taskId: "domain_assignment",
+            systemPrompt: 'Classify which agent domain(s) should handle this task. Return JSON: {"domains": [...]} with 1-2 values from: engineering, product, design, marketing, sales, operations. Be precise based on the task content.',
+            userPrompt: `Task: ${input.title}\n${input.summary ? `Details: ${input.summary}` : ""}`,
+            maxTokens: 64,
+            temperature: 0.1,
+            cacheTtlMs: 60 * 60_000, // 1 hour
+        }, (raw) => {
+            try {
+                const parsed = JSON.parse(raw);
+                if (Array.isArray(parsed.domains) &&
+                    parsed.domains.length > 0 &&
+                    parsed.domains.every((d) => typeof d === "string" && VALID_DOMAINS.has(d))) {
+                    return { domains: parsed.domains };
+                }
+            }
+            catch {
+                // fall through
+            }
+            return null;
+        }, () => ({ domains: heuristicDomainGuess(input.title, input.summary ?? null) }));
+        const domainHints = domainResult.result.domains;
+        for (const domain of domainHints) {
+            const match = liveAgents.find((agent) => (agent.domain ?? "").toLowerCase().includes(domain));
+            if (match)
+                addAgent(match);
+        }
+    }
+    if (byKey.size === 0 && liveAgents.length > 0) {
+        addAgent(liveAgents[0]);
+        warnings.push("fallback selected first available live agent");
+    }
+    const assignedAgents = Array.from(byKey.values());
+    let updatedEntity = null;
+    try {
+        updatedEntity = (await input.client.updateEntity(input.entityType, input.entityId, {
+            assigned_agent_ids: assignedAgents.map((agent) => agent.id),
+            assigned_agent_names: assignedAgents.map((agent) => agent.name),
+            assignment_source: assignmentSource,
+        }));
+    }
+    catch (err) {
+        warnings.push(`assignment update failed (${input.toErrorMessage(err)})`);
+    }
+    return {
+        assignmentSource,
+        assignedAgents,
+        warnings,
+        updatedEntity,
+    };
+}

package/dist/entity-comment-store.js

@@ -1,7 +1,8 @@
-import { chmodSync, existsSync, mkdirSync, readFileSync, rmSync, } from "node:fs";
+import { existsSync, readFileSync, } from "node:fs";
 import { randomUUID } from "node:crypto";
 import { getOrgxPluginConfigDir, getOrgxPluginConfigPath } from "./paths.js";
 import { backupCorruptFileSync, writeJsonFileAtomicSync } from "./fs-utils.js";
+import { clearStoreFileSync, ensureStoreDirSync, parseJsonSafe, } from "./stores/json-store.js";
 const MAX_COMMENTS_PER_ENTITY = 240;
 const MAX_TOTAL_COMMENTS = 1_500;
 function commentsDir() {
@@ -11,22 +12,7 @@ function commentsFile() {
     return getOrgxPluginConfigPath("entity-comments.json");
 }
 function ensureDir() {
-    const dir = commentsDir();
-    mkdirSync(dir, { recursive: true, mode: 0o700 });
-    try {
-        chmodSync(dir, 0o700);
-    }
-    catch {
-        // best effort
-    }
-}
-function parseJson(value) {
-    try {
-        return JSON.parse(value);
-    }
-    catch {
-        return null;
-    }
+    ensureStoreDirSync(commentsDir());
 }
 function entityKey(entityType, entityId) {
     return `${entityType.trim().toLowerCase()}:${entityId.trim()}`;
@@ -63,7 +49,7 @@ function readStore() {
             return { updatedAt: new Date().toISOString(), commentsByEntity: {} };
         }
         const raw = readFileSync(file, "utf8");
-        const parsed = parseJson(raw);
+        const parsed = parseJsonSafe(raw);
         if (!parsed || typeof parsed !== "object") {
             backupCorruptFileSync(file);
             return { updatedAt: new Date().toISOString(), commentsByEntity: {} };
@@ -180,11 +166,5 @@ export function mergeEntityComments(remote, local) {
     return list;
 }
 export function clearEntityCommentsStore() {
-    const file = commentsFile();
-    try {
-        rmSync(file, { force: true });
-    }
-    catch {
-        // best effort
-    }
+    clearStoreFileSync(commentsFile());
 }

package/dist/event-sanitization.d.ts

@@ -0,0 +1,11 @@
+import type { LiveActivityItem } from "./contracts/shared-types.js";
+export declare function isUuid(value: string | null | undefined): boolean;
+export declare function isSyntheticIdentifier(value: string | null | undefined): boolean;
+type OutboxEventLike = {
+    type?: unknown;
+    payload?: unknown;
+    activityItem?: unknown;
+};
+export declare function classifyOutboxReplaySkip(event: OutboxEventLike): string | null;
+export declare function shouldHideActivityItem(item: LiveActivityItem): boolean;
+export {};

package/dist/event-sanitization.js

@@ -0,0 +1,113 @@
+function toRecord(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return null;
+    return value;
+}
+function pickString(input, ...keys) {
+    if (!input)
+        return null;
+    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 pickBool(input, ...keys) {
+    if (!input)
+        return false;
+    for (const key of keys) {
+        if (input[key] === true)
+            return true;
+    }
+    return false;
+}
+function containsMockMarker(value) {
+    if (!value)
+        return false;
+    const normalized = value.trim().toLowerCase();
+    if (!normalized)
+        return false;
+    // Match whole marker tokens and avoid substring false positives (e.g. "latest").
+    return /(^|[^a-z0-9])(mock|fixture|synthetic|test)([^a-z0-9]|$)/i.test(normalized);
+}
+export function isUuid(value) {
+    if (!value)
+        return false;
+    const trimmed = value.trim();
+    if (!trimmed)
+        return false;
+    return /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(trimmed);
+}
+export function isSyntheticIdentifier(value) {
+    if (!value)
+        return false;
+    const trimmed = value.trim();
+    if (!trimmed)
+        return false;
+    if (isUuid(trimmed))
+        return false;
+    return /^(init|initiative|task|workstream|ws|milestone|ms|decision|artifact|demo|mock|test|sample|queue|tmp|local)-/i.test(trimmed);
+}
+function isMockTaggedMetadata(metadata) {
+    if (!metadata)
+        return false;
+    if (pickBool(metadata, "mock", "is_mock", "isMock"))
+        return true;
+    if (containsMockMarker(pickString(metadata, "source")) ||
+        containsMockMarker(pickString(metadata, "worker_kind", "workerKind")) ||
+        containsMockMarker(pickString(metadata, "environment"))) {
+        return true;
+    }
+    return false;
+}
+export function classifyOutboxReplaySkip(event) {
+    const eventType = typeof event.type === "string" ? event.type.trim().toLowerCase() : "";
+    const payload = toRecord(event.payload);
+    const activity = toRecord(event.activityItem);
+    const payloadMetadata = toRecord(payload?.metadata);
+    const activityMetadata = toRecord(activity?.metadata);
+    const normalizedSourceClient = pickString(payload, "source_client", "sourceClient")
+        ?.trim()
+        .toLowerCase();
+    const normalizedPayloadEvent = pickString(payloadMetadata, "event")?.trim().toLowerCase();
+    const normalizedActivityEvent = pickString(activityMetadata, "event")?.trim().toLowerCase();
+    const skipMockOutboxReplay = String(process.env.ORGX_SKIP_MOCK_OUTBOX_REPLAY ?? "false")
+        .trim()
+        .toLowerCase() === "true";
+    if (skipMockOutboxReplay &&
+        (isMockTaggedMetadata(payloadMetadata) ||
+            isMockTaggedMetadata(activityMetadata) ||
+            pickBool(payload, "mock", "is_mock", "isMock"))) {
+        return "mock_event";
+    }
+    if (eventType === "artifact") {
+        const initiativeId = pickString(payload, "initiative_id", "initiativeId");
+        const entityId = pickString(payload, "entity_id", "entityId");
+        const allowSyntheticArtifact = normalizedSourceClient === "openclaw" ||
+            normalizedPayloadEvent === "autopilot_slice_artifact_buffered" ||
+            normalizedActivityEvent === "autopilot_slice_artifact_buffered";
+        if (!allowSyntheticArtifact && isSyntheticIdentifier(initiativeId)) {
+            return "synthetic_initiative_id";
+        }
+        if (!allowSyntheticArtifact && !entityId) {
+            return "missing_artifact_entity_id";
+        }
+        if (!allowSyntheticArtifact && isSyntheticIdentifier(entityId)) {
+            return "synthetic_artifact_entity_id";
+        }
+    }
+    return null;
+}
+export function shouldHideActivityItem(item) {
+    const metadata = toRecord(item.metadata);
+    const hideMockActivity = String(process.env.ORGX_HIDE_MOCK_ACTIVITY ?? "false")
+        .trim()
+        .toLowerCase() === "true";
+    if (hideMockActivity && isMockTaggedMetadata(metadata))
+        return true;
+    return false;
+}

package/dist/fs-utils.js

@@ -1,5 +1,14 @@
 import { chmodSync, renameSync, unlinkSync, writeFileSync } from "node:fs";
 import { randomUUID } from "node:crypto";
+function isSafeFilePath(path) {
+    if (!path)
+        return false;
+    if (/[\u0000-\u001f\u007f]/.test(path))
+        return false;
+    if (/\\0|\\x00|\\u0000|%00/i.test(path))
+        return false;
+    return true;
+}
 function hardenPath(path, mode) {
     try {
         chmodSync(path, mode);
@@ -9,7 +18,7 @@ function hardenPath(path, mode) {
     }
 }
 export function backupCorruptFileSync(targetPath) {
-    if (!targetPath || targetPath.includes("\0"))
+    if (!isSafeFilePath(targetPath))
         return null;
     const suffix = `${Date.now()}-${randomUUID().slice(0, 8)}`;
     const backupPath = `${targetPath}.corrupt.${suffix}`;
@@ -23,6 +32,9 @@ export function backupCorruptFileSync(targetPath) {
     }
 }
 export function writeFileAtomicSync(targetPath, content, options) {
+    if (!isSafeFilePath(targetPath)) {
+        throw new TypeError("targetPath must be a safe, non-empty file path");
+    }
     const mode = options?.mode ?? 0o600;
     const encoding = options?.encoding ?? "utf8";
     const tmpPath = `${targetPath}.tmp.${process.pid}.${randomUUID().slice(0, 8)}`;

package/dist/gateway-watchdog.d.ts

@@ -8,4 +8,9 @@ export declare function ensureGatewayWatchdog(logger: Logger): {
     started: boolean;
     pid: number | null;
 };
+export declare function stopGatewayWatchdog(logger?: Logger, timeoutMs?: number): Promise<{
+    pid: number | null;
+    wasRunning: boolean;
+    stopped: boolean;
+}>;
 export {};

package/dist/gateway-watchdog.js

@@ -8,6 +8,31 @@ const DEFAULT_MONITOR_INTERVAL_MS = 30_000;
 const DEFAULT_FAILURES_BEFORE_RESTART = 2;
 const DEFAULT_PROBE_TIMEOUT_MS = 2_500;
 const WATCHDOG_PID_FILE = join(getOpenClawDir(), "orgx-gateway-watchdog.pid");
+function sendSignal(pid, signal) {
+    try {
+        // Detached child uses its own process group on Unix.
+        process.kill(-pid, signal);
+        return;
+    }
+    catch {
+        // Fall through to direct pid kill.
+    }
+    try {
+        process.kill(pid, signal);
+    }
+    catch {
+        // best effort
+    }
+}
+async function waitForExit(pid, timeoutMs) {
+    const deadline = Date.now() + Math.max(100, timeoutMs);
+    while (Date.now() < deadline) {
+        if (!isPidAlive(pid))
+            return true;
+        await new Promise((resolve) => setTimeout(resolve, 100));
+    }
+    return !isPidAlive(pid);
+}
 function readEnvNumber(name, fallback, min) {
     const raw = (process.env[name] ?? "").trim();
     if (!raw)
@@ -219,3 +244,28 @@ export function ensureGatewayWatchdog(logger) {
     child.unref();
     return { started: true, pid: child.pid ?? null };
 }
+export async function stopGatewayWatchdog(logger = console, timeoutMs = 1_500) {
+    const pid = readWatchdogPid();
+    if (!pid) {
+        clearWatchdogPid();
+        return { pid: null, wasRunning: false, stopped: true };
+    }
+    if (!isPidAlive(pid)) {
+        clearWatchdogPid();
+        return { pid, wasRunning: false, stopped: true };
+    }
+    sendSignal(pid, "SIGTERM");
+    let stopped = await waitForExit(pid, timeoutMs);
+    if (!stopped) {
+        sendSignal(pid, "SIGKILL");
+        stopped = await waitForExit(pid, 500);
+    }
+    if (stopped) {
+        clearWatchdogPid();
+        logger.info?.("[orgx] Gateway watchdog stopped", { pid });
+    }
+    else {
+        logger.warn?.("[orgx] Gateway watchdog did not exit after stop attempt", { pid });
+    }
+    return { pid, wasRunning: true, stopped };
+}

package/dist/hash-utils.d.ts

@@ -0,0 +1,2 @@
+export declare function stableHash(value: string): string;
+export declare function idempotencyKey(parts: Array<string | null | undefined>): string;

package/dist/hash-utils.js

@@ -0,0 +1,12 @@
+import { createHash } from "node:crypto";
+export function stableHash(value) {
+    return createHash("sha256").update(value).digest("hex");
+}
+export function idempotencyKey(parts) {
+    const raw = parts
+        .filter((part) => typeof part === "string" && part.length > 0)
+        .join(":");
+    const cleaned = raw.replace(/[^a-zA-Z0-9:_-]/g, "-").slice(0, 84);
+    const suffix = stableHash(raw).slice(0, 20);
+    return `${cleaned}:${suffix}`.slice(0, 120);
+}

package/dist/hooks/post-reporting-event.mjs

@@ -168,11 +168,7 @@ export async function main({
   const runId = pickString(args.run_id, env.ORGX_RUN_ID);
   const correlationId = runId
     ? undefined
-    : pickString(
-        args.correlation_id,
-        env.ORGX_CORRELATION_ID,
-        `hook-${now()}`
-      );
+    : pickString(args.correlation_id, env.ORGX_CORRELATION_ID);
 
   const event = pickString(args.event, "hook_event");
   const phase = pickString(args.phase, "execution");

package/dist/http/helpers/activity-headline.d.ts

@@ -0,0 +1,10 @@
+export type ActivityHeadlineSource = "llm" | "heuristic";
+export declare function summarizeActivityHeadline(input: {
+    text: string;
+    title?: string | null;
+    type?: string | null;
+}): Promise<{
+    headline: string;
+    source: ActivityHeadlineSource;
+    model: string | null;
+}>;

package/dist/http/helpers/activity-headline.js

@@ -0,0 +1,73 @@
+import { callLlm } from "./llm-client.js";
+const ACTIVITY_HEADLINE_MAX_INPUT_CHARS = 8_000;
+const DEFAULT_ACTIVITY_HEADLINE_MODEL = "openai/gpt-4.1-nano";
+function normalizeSpaces(value) {
+    return value.replace(/\s+/g, " ").trim();
+}
+function stripMarkdownLite(value) {
+    return value
+        .replace(/```[\s\S]*?```/g, " ")
+        .replace(/`([^`]+)`/g, "$1")
+        .replace(/\*\*([^*]+)\*\*/g, "$1")
+        .replace(/__([^_]+)__/g, "$1")
+        .replace(/\*([^*\n]+)\*/g, "$1")
+        .replace(/_([^_\n]+)_/g, "$1")
+        .replace(/\[([^\]]+)\]\(([^)\s]+)\)/g, "$1")
+        .replace(/^\s{0,3}#{1,6}\s+/gm, "")
+        .replace(/^\s*[-*]\s+/gm, "")
+        .replace(/^\s*\d+\.\s+/gm, "")
+        .replace(/\r\n/g, "\n")
+        .trim();
+}
+function cleanActivityHeadline(value) {
+    const lines = stripMarkdownLite(value)
+        .split("\n")
+        .map((line) => normalizeSpaces(line))
+        .filter((line) => line.length > 0 && !/^\|?[:\-| ]+\|?$/.test(line));
+    const headline = lines[0] ?? "";
+    if (!headline)
+        return "";
+    if (headline.length <= 108)
+        return headline;
+    return `${headline.slice(0, 107).trimEnd()}…`;
+}
+function heuristicActivityHeadline(text, title) {
+    const cleanedText = cleanActivityHeadline(text);
+    if (cleanedText.length > 0)
+        return cleanedText;
+    const cleanedTitle = cleanActivityHeadline(title ?? "");
+    if (cleanedTitle.length > 0)
+        return cleanedTitle;
+    return "Activity update";
+}
+export async function summarizeActivityHeadline(input) {
+    const normalizedText = normalizeSpaces(input.text).slice(0, ACTIVITY_HEADLINE_MAX_INPUT_CHARS);
+    const normalizedTitle = normalizeSpaces(input.title ?? "");
+    const normalizedType = normalizeSpaces(input.type ?? "");
+    const userPrompt = [
+        "Create one short activity title for a dashboard header.",
+        "Rules:",
+        "- Max 96 characters.",
+        "- Keep key numbers/status markers (for example: 15 tasks, 0 blocked).",
+        "- No markdown, no quotes, no trailing period unless needed.",
+        "- Prefer plain language over jargon.",
+        "",
+        `Type: ${normalizedType || "activity"}`,
+        normalizedTitle ? `Current title: ${normalizedTitle}` : "",
+        "Full detail:",
+        normalizedText,
+    ]
+        .filter(Boolean)
+        .join("\n");
+    const model = process.env.ORGX_ACTIVITY_SUMMARY_MODEL?.trim() || DEFAULT_ACTIVITY_HEADLINE_MODEL;
+    const response = await callLlm({
+        taskId: "activity_headline",
+        systemPrompt: "You write concise activity headers for operational dashboards. Return only the header text.",
+        userPrompt,
+        model,
+        temperature: 0.1,
+        maxTokens: 48,
+        timeoutMs: 4_000,
+    }, () => heuristicActivityHeadline(normalizedText, normalizedTitle), (raw) => cleanActivityHeadline(raw) || null);
+    return { headline: response.result, source: response.source, model: response.model };
+}

package/dist/http/helpers/artifact-fallback.d.ts

@@ -0,0 +1,13 @@
+import type { LiveActivityItem } from "../../types.js";
+type ListActivityPageResult = {
+    activities: LiveActivityItem[];
+    nextCursor: string | null;
+};
+type BuildArtifactFallbackDeps = {
+    listActivityPage: (input: {
+        limit: number;
+        cursor: string | null;
+    }) => ListActivityPageResult;
+};
+export declare function createLocalArtifactDetailFallbackBuilder(deps: BuildArtifactFallbackDeps): (artifactId: string, warning: string) => Record<string, unknown> | null;
+export {};