@useorgx/openclaw-plugin 0.4.9 → 0.7.2

package/dist/contracts/shared-types.js

@@ -1,3 +1,201 @@
 // Canonical shared types consumed by both core plugin code and dashboard code.
 // Keep this file dependency-free so it can be imported across build boundaries.
-export {};
+export const KNOWN_ACTIVITY_ACTION_TYPES = [
+    "orchestrator_dispatch",
+    "dispatch_slice",
+    "spawn_worker",
+    "run_heartbeat",
+    "run_state_transition",
+    "run_started",
+    "run_completed",
+    "run_failed",
+    "slice_handoff",
+    "question_asked",
+    "question_timeout_started",
+    "question_auto_answered",
+    "question_answer_applied",
+    "question_answer_failed",
+    "decision_requested",
+    "decision_resolved",
+    "review_item_created",
+    "review_item_resolved",
+    "status_updates_applied",
+    "status_updates_buffered",
+    "artifact_registered",
+    "spawn_guard_blocked",
+    "spawn_guard_rate_limited",
+    "behavior_config_review",
+    "auto_fix",
+    "auto_continue_started",
+    "auto_continue_stopped",
+    "autopilot_resumed",
+    "autopilot_paused",
+    "autopilot_blocked",
+    "milestone_completed",
+    "workflow_error",
+];
+export const KNOWN_ACTIVITY_ACTION_PHASES = [
+    "intent",
+    "dispatch",
+    "execution",
+    "handoff",
+    "review",
+    "completed",
+    "blocked",
+    "error",
+];
+const ACTIVITY_ACTION_TYPE_ALIASES = {
+    orchestrator: "orchestrator_dispatch",
+    dispatch: "dispatch_slice",
+    dispatched: "dispatch_slice",
+    question: "question_asked",
+    question_timeout: "question_timeout_started",
+    question_auto_answer: "question_auto_answered",
+    decision_auto_answer: "question_auto_answered",
+    decision_auto_answer_applied: "question_answer_applied",
+    decision_auto_answer_failed: "question_answer_failed",
+    decision_auto_answer_skipped: "review_item_created",
+    start: "run_started",
+    started: "run_started",
+    stop: "auto_continue_stopped",
+    stopped: "auto_continue_stopped",
+    pause: "autopilot_paused",
+    paused: "autopilot_paused",
+    resume: "autopilot_resumed",
+    resumed: "autopilot_resumed",
+    blocked: "autopilot_blocked",
+    complete: "run_completed",
+    completed: "run_completed",
+    fail: "run_failed",
+    failed: "run_failed",
+};
+export function normalizeActivityActionType(value) {
+    if (typeof value !== "string")
+        return null;
+    const normalized = value.trim().toLowerCase();
+    if (!normalized)
+        return null;
+    const alias = ACTIVITY_ACTION_TYPE_ALIASES[normalized];
+    if (alias)
+        return alias;
+    return normalized.replace(/\s+/g, "_");
+}
+export function isKnownActivityActionType(value) {
+    if (typeof value !== "string")
+        return false;
+    return KNOWN_ACTIVITY_ACTION_TYPES.includes(value);
+}
+export function normalizeActivityActionPhase(value) {
+    if (typeof value !== "string")
+        return null;
+    const normalized = value.trim().toLowerCase();
+    if (!normalized)
+        return null;
+    if (KNOWN_ACTIVITY_ACTION_PHASES.includes(normalized)) {
+        return normalized;
+    }
+    return null;
+}
+export const KNOWN_DECISION_ACTION_TYPES = [
+    "approve",
+    "reject",
+    "provide_context",
+    "request_info",
+    "confirm_scope",
+    "retry",
+    "resume",
+    "start",
+    "pause",
+    "defer",
+    "cancel",
+    "queue_top",
+    "queue_bottom",
+    "remove_from_queue",
+    "reassign",
+    "assign",
+    "notify",
+    "escalate",
+    "handoff",
+    "spawn",
+    "execute_task",
+    "review_blocker",
+    "review_decision",
+    "open_artifact",
+    "open_logs",
+    "open_session",
+    "open_run",
+    "open_workstream",
+    "open_task",
+    "open_initiative",
+    "open_pr",
+    "open_diff",
+    "open_branch",
+    "open_deal",
+    "update_deal",
+    "open_settings",
+    "open_workspace",
+    "connect_provider",
+    "refresh_credentials",
+    "auto_fix",
+    "ignore_once",
+];
+const DECISION_ACTION_TYPE_ALIASES = {
+    declined: "reject",
+    decline: "reject",
+    deny: "reject",
+    dismiss: "ignore_once",
+    retry_slice: "retry",
+    continue: "resume",
+    restart: "resume",
+    play: "start",
+    stop: "pause",
+    snooze: "defer",
+    queue: "queue_bottom",
+    add_to_end: "queue_bottom",
+    add_to_queue: "queue_bottom",
+    queue_to_end: "queue_bottom",
+    queue_to_bottom: "queue_bottom",
+    queue_to_top: "queue_top",
+    move_to_top: "queue_top",
+    move_to_bottom: "queue_bottom",
+    remove: "remove_from_queue",
+    remove_queue: "remove_from_queue",
+    unqueue: "remove_from_queue",
+    openartifact: "open_artifact",
+    open_artifacts: "open_artifact",
+    open_pr_diff: "open_diff",
+    open_pull_request: "open_pr",
+    open_work_item: "open_task",
+    providecontext: "provide_context",
+    request_context: "request_info",
+    ask_info: "request_info",
+    ask_question: "request_info",
+    reassign_agent: "reassign",
+    assign_agent: "assign",
+    spawn_agent: "spawn",
+    connect_credentials: "connect_provider",
+    fix_credentials: "refresh_credentials",
+    refresh_credential: "refresh_credentials",
+    autofix: "auto_fix",
+    auto_resolve: "auto_fix",
+};
+const KNOWN_DECISION_ACTION_TYPE_SET = new Set(KNOWN_DECISION_ACTION_TYPES);
+export function normalizeDecisionActionType(value) {
+    if (typeof value !== "string")
+        return null;
+    const normalized = value.trim().toLowerCase();
+    if (!normalized)
+        return null;
+    if (KNOWN_DECISION_ACTION_TYPE_SET.has(normalized)) {
+        return normalized;
+    }
+    if (DECISION_ACTION_TYPE_ALIASES[normalized]) {
+        return DECISION_ACTION_TYPE_ALIASES[normalized];
+    }
+    return normalized;
+}
+export function isKnownDecisionActionType(value) {
+    if (typeof value !== "string")
+        return false;
+    return KNOWN_DECISION_ACTION_TYPE_SET.has(value.trim().toLowerCase());
+}

package/dist/contracts/skill-pack-schema.d.ts

@@ -0,0 +1,192 @@
+export declare const OPENCLAW_SKILL_PACK_SCHEMA_VERSION: "openclaw-skill-pack.v1";
+export declare const ORGX_AGENT_DOMAINS: readonly ["engineering", "product", "design", "marketing", "sales", "operations", "orchestration"];
+export type OrgxAgentDomainName = (typeof ORGX_AGENT_DOMAINS)[number];
+export type ManifestConfigType = "openclaw_skills" | "openclawSkills" | "openclaw.skills" | "none";
+export declare const OPENCLAW_SKILLS_MAP_JSON_SCHEMA: {
+    readonly type: "object";
+    readonly additionalProperties: false;
+    readonly properties: {
+        readonly engineering: {
+            readonly type: "string";
+            readonly minLength: 1;
+        };
+        readonly product: {
+            readonly type: "string";
+            readonly minLength: 1;
+        };
+        readonly design: {
+            readonly type: "string";
+            readonly minLength: 1;
+        };
+        readonly marketing: {
+            readonly type: "string";
+            readonly minLength: 1;
+        };
+        readonly sales: {
+            readonly type: "string";
+            readonly minLength: 1;
+        };
+        readonly operations: {
+            readonly type: "string";
+            readonly minLength: 1;
+        };
+        readonly orchestration: {
+            readonly type: "string";
+            readonly minLength: 1;
+        };
+    };
+};
+export declare const OPENCLAW_SKILL_PACK_MANIFEST_JSON_SCHEMA: {
+    readonly $schema: "https://json-schema.org/draft/2020-12/schema";
+    readonly $id: "https://schemas.useorgx.com/openclaw-skill-pack/v1.json";
+    readonly title: "OrgX OpenClaw Skill Pack Manifest";
+    readonly description: "Behavior config manifest for OpenClaw skill overrides by domain.";
+    readonly type: "object";
+    readonly additionalProperties: true;
+    readonly oneOf: readonly [{
+        readonly type: "object";
+        readonly additionalProperties: true;
+        readonly properties: {
+            readonly schema_version: {
+                readonly type: "string";
+                readonly const: "openclaw-skill-pack.v1";
+            };
+            readonly openclaw_skills: {
+                readonly type: "object";
+                readonly additionalProperties: false;
+                readonly properties: {
+                    readonly engineering: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                    };
+                    readonly product: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                    };
+                    readonly design: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                    };
+                    readonly marketing: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                    };
+                    readonly sales: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                    };
+                    readonly operations: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                    };
+                    readonly orchestration: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                    };
+                };
+            };
+        };
+        readonly required: readonly ["openclaw_skills"];
+    }, {
+        readonly type: "object";
+        readonly additionalProperties: true;
+        readonly properties: {
+            readonly schema_version: {
+                readonly type: "string";
+                readonly const: "openclaw-skill-pack.v1";
+            };
+            readonly openclawSkills: {
+                readonly type: "object";
+                readonly additionalProperties: false;
+                readonly properties: {
+                    readonly engineering: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                    };
+                    readonly product: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                    };
+                    readonly design: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                    };
+                    readonly marketing: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                    };
+                    readonly sales: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                    };
+                    readonly operations: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                    };
+                    readonly orchestration: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                    };
+                };
+            };
+        };
+        readonly required: readonly ["openclawSkills"];
+    }, {
+        readonly type: "object";
+        readonly additionalProperties: true;
+        readonly properties: {
+            readonly schema_version: {
+                readonly type: "string";
+                readonly const: "openclaw-skill-pack.v1";
+            };
+            readonly openclaw: {
+                readonly type: "object";
+                readonly additionalProperties: true;
+                readonly properties: {
+                    readonly skills: {
+                        readonly type: "object";
+                        readonly additionalProperties: false;
+                        readonly properties: {
+                            readonly engineering: {
+                                readonly type: "string";
+                                readonly minLength: 1;
+                            };
+                            readonly product: {
+                                readonly type: "string";
+                                readonly minLength: 1;
+                            };
+                            readonly design: {
+                                readonly type: "string";
+                                readonly minLength: 1;
+                            };
+                            readonly marketing: {
+                                readonly type: "string";
+                                readonly minLength: 1;
+                            };
+                            readonly sales: {
+                                readonly type: "string";
+                                readonly minLength: 1;
+                            };
+                            readonly operations: {
+                                readonly type: "string";
+                                readonly minLength: 1;
+                            };
+                            readonly orchestration: {
+                                readonly type: "string";
+                                readonly minLength: 1;
+                            };
+                        };
+                    };
+                };
+                readonly required: readonly ["skills"];
+            };
+        };
+        readonly required: readonly ["openclaw"];
+    }];
+};
+export declare function validateOpenClawSkillPackManifest(manifest: unknown): {
+    ok: boolean;
+    configType: ManifestConfigType;
+    openclaw_skills: Partial<Record<OrgxAgentDomainName, string>>;
+    errors: string[];
+};

package/dist/contracts/skill-pack-schema.js

@@ -0,0 +1,180 @@
+export const OPENCLAW_SKILL_PACK_SCHEMA_VERSION = "openclaw-skill-pack.v1";
+export const ORGX_AGENT_DOMAINS = [
+    "engineering",
+    "product",
+    "design",
+    "marketing",
+    "sales",
+    "operations",
+    "orchestration",
+];
+const DOMAIN_SET = new Set(ORGX_AGENT_DOMAINS);
+function isRecord(value) {
+    return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
+function hasOwn(record, key) {
+    return Object.prototype.hasOwnProperty.call(record, key);
+}
+const DOMAIN_STRING_SCHEMA = {
+    type: "string",
+    minLength: 1,
+};
+export const OPENCLAW_SKILLS_MAP_JSON_SCHEMA = {
+    type: "object",
+    additionalProperties: false,
+    properties: {
+        engineering: DOMAIN_STRING_SCHEMA,
+        product: DOMAIN_STRING_SCHEMA,
+        design: DOMAIN_STRING_SCHEMA,
+        marketing: DOMAIN_STRING_SCHEMA,
+        sales: DOMAIN_STRING_SCHEMA,
+        operations: DOMAIN_STRING_SCHEMA,
+        orchestration: DOMAIN_STRING_SCHEMA,
+    },
+};
+export const OPENCLAW_SKILL_PACK_MANIFEST_JSON_SCHEMA = {
+    $schema: "https://json-schema.org/draft/2020-12/schema",
+    $id: "https://schemas.useorgx.com/openclaw-skill-pack/v1.json",
+    title: "OrgX OpenClaw Skill Pack Manifest",
+    description: "Behavior config manifest for OpenClaw skill overrides by domain.",
+    type: "object",
+    additionalProperties: true,
+    oneOf: [
+        {
+            type: "object",
+            additionalProperties: true,
+            properties: {
+                schema_version: { type: "string", const: OPENCLAW_SKILL_PACK_SCHEMA_VERSION },
+                openclaw_skills: OPENCLAW_SKILLS_MAP_JSON_SCHEMA,
+            },
+            required: ["openclaw_skills"],
+        },
+        {
+            type: "object",
+            additionalProperties: true,
+            properties: {
+                schema_version: { type: "string", const: OPENCLAW_SKILL_PACK_SCHEMA_VERSION },
+                openclawSkills: OPENCLAW_SKILLS_MAP_JSON_SCHEMA,
+            },
+            required: ["openclawSkills"],
+        },
+        {
+            type: "object",
+            additionalProperties: true,
+            properties: {
+                schema_version: { type: "string", const: OPENCLAW_SKILL_PACK_SCHEMA_VERSION },
+                openclaw: {
+                    type: "object",
+                    additionalProperties: true,
+                    properties: {
+                        skills: OPENCLAW_SKILLS_MAP_JSON_SCHEMA,
+                    },
+                    required: ["skills"],
+                },
+            },
+            required: ["openclaw"],
+        },
+    ],
+};
+function resolveManifestConfigType(manifest) {
+    const hasOpenclawSkills = hasOwn(manifest, "openclaw_skills");
+    const hasOpenclawSkillsCamel = hasOwn(manifest, "openclawSkills");
+    const openclaw = manifest.openclaw;
+    const hasOpenclawNestedSkills = isRecord(openclaw) && hasOwn(openclaw, "skills");
+    const errors = [];
+    const selectedConfigTypes = [
+        hasOpenclawSkills ? "openclaw_skills" : null,
+        hasOpenclawSkillsCamel ? "openclawSkills" : null,
+        hasOpenclawNestedSkills ? "openclaw.skills" : null,
+    ].filter((value) => value !== null);
+    if (selectedConfigTypes.length > 1) {
+        errors.push("manifest must define only one config container: openclaw_skills, openclawSkills, or openclaw.skills");
+    }
+    if (hasOpenclawSkills) {
+        const value = manifest.openclaw_skills;
+        if (!isRecord(value)) {
+            return {
+                type: "openclaw_skills",
+                rawMap: null,
+                errors: [...errors, "manifest.openclaw_skills must be an object"],
+            };
+        }
+        return { type: "openclaw_skills", rawMap: value, errors };
+    }
+    if (hasOpenclawSkillsCamel) {
+        const value = manifest.openclawSkills;
+        if (!isRecord(value)) {
+            return {
+                type: "openclawSkills",
+                rawMap: null,
+                errors: [...errors, "manifest.openclawSkills must be an object"],
+            };
+        }
+        return { type: "openclawSkills", rawMap: value, errors };
+    }
+    if (hasOpenclawNestedSkills) {
+        const value = openclaw.skills;
+        if (!isRecord(value)) {
+            return {
+                type: "openclaw.skills",
+                rawMap: null,
+                errors: [...errors, "manifest.openclaw.skills must be an object"],
+            };
+        }
+        return { type: "openclaw.skills", rawMap: value, errors };
+    }
+    return { type: "none", rawMap: null, errors };
+}
+export function validateOpenClawSkillPackManifest(manifest) {
+    if (!isRecord(manifest)) {
+        return {
+            ok: false,
+            configType: "none",
+            openclaw_skills: {},
+            errors: ["manifest must be an object"],
+        };
+    }
+    const errors = [];
+    if ("schema_version" in manifest) {
+        const version = manifest.schema_version;
+        if (typeof version !== "string") {
+            errors.push("manifest.schema_version must be a string");
+        }
+        else if (version.trim() !== OPENCLAW_SKILL_PACK_SCHEMA_VERSION) {
+            errors.push(`manifest.schema_version must equal "${OPENCLAW_SKILL_PACK_SCHEMA_VERSION}"`);
+        }
+    }
+    const { type, rawMap, errors: manifestConfigErrors } = resolveManifestConfigType(manifest);
+    errors.push(...manifestConfigErrors);
+    if (!rawMap) {
+        return {
+            ok: errors.length === 0,
+            configType: type,
+            openclaw_skills: {},
+            errors,
+        };
+    }
+    const openclaw_skills = {};
+    for (const [domain, rawValue] of Object.entries(rawMap)) {
+        if (!DOMAIN_SET.has(domain)) {
+            errors.push(`unknown domain key "${domain}" in manifest ${type}`);
+            continue;
+        }
+        if (typeof rawValue !== "string") {
+            errors.push(`manifest ${type}.${domain} must be a string`);
+            continue;
+        }
+        const normalized = rawValue.trim();
+        if (!normalized) {
+            errors.push(`manifest ${type}.${domain} must not be empty`);
+            continue;
+        }
+        openclaw_skills[domain] = normalized;
+    }
+    return {
+        ok: errors.length === 0,
+        configType: type,
+        openclaw_skills,
+        errors,
+    };
+}