@useorgx/openclaw-plugin 0.4.5 → 0.4.8

package/dist/activity-actor-fields.js

@@ -0,0 +1,128 @@
+function asRecord(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return null;
+    return value;
+}
+function nonEmptyString(value) {
+    if (typeof value !== "string")
+        return null;
+    const trimmed = value.trim();
+    return trimmed.length > 0 ? trimmed : null;
+}
+function firstString(record, keys) {
+    if (!record)
+        return null;
+    for (const key of keys) {
+        const candidate = nonEmptyString(record[key]);
+        if (candidate)
+            return candidate;
+    }
+    return null;
+}
+function normalizedMetadata(item) {
+    const metadata = asRecord(item.metadata);
+    if (!metadata)
+        return null;
+    const nested = asRecord(metadata.metadata);
+    if (!nested)
+        return metadata;
+    return { ...metadata, ...nested };
+}
+function hasActorValue(id, name) {
+    return Boolean((id && id.trim().length > 0) || (name && name.trim().length > 0));
+}
+export function enrichActivityActorFields(item) {
+    const metadata = normalizedMetadata(item);
+    let requesterAgentId = nonEmptyString(item.requesterAgentId) ??
+        firstString(metadata, [
+            "requested_by_agent_id",
+            "requestedByAgentId",
+            "requester_agent_id",
+            "requesterAgentId",
+            "requester_id",
+            "requesterId",
+            "runner_agent_id",
+            "runnerAgentId",
+            "handoff_from_agent_id",
+            "handoffFromAgentId",
+            "from_agent_id",
+            "fromAgentId",
+            "source_agent_id",
+            "sourceAgentId",
+        ]);
+    let requesterAgentName = nonEmptyString(item.requesterAgentName) ??
+        firstString(metadata, [
+            "requested_by_agent_name",
+            "requestedByAgentName",
+            "requester_agent_name",
+            "requesterAgentName",
+            "requester_name",
+            "requesterName",
+            "runner_agent_name",
+            "runnerAgentName",
+            "handoff_from_agent_name",
+            "handoffFromAgentName",
+            "from_agent_name",
+            "fromAgentName",
+            "source_agent_name",
+            "sourceAgentName",
+        ]);
+    const executorAgentId = nonEmptyString(item.executorAgentId) ??
+        firstString(metadata, [
+            "executed_by_agent_id",
+            "executedByAgentId",
+            "executor_agent_id",
+            "executorAgentId",
+            "executor_id",
+            "executorId",
+            "delegated_to_agent_id",
+            "delegatedToAgentId",
+            "handoff_to_agent_id",
+            "handoffToAgentId",
+            "target_agent_id",
+            "targetAgentId",
+            "agent_id",
+            "agentId",
+        ]) ??
+        nonEmptyString(item.agentId);
+    const executorAgentName = nonEmptyString(item.executorAgentName) ??
+        firstString(metadata, [
+            "executed_by_agent_name",
+            "executedByAgentName",
+            "executor_agent_name",
+            "executorAgentName",
+            "executor_name",
+            "executorName",
+            "delegated_to_agent_name",
+            "delegatedToAgentName",
+            "handoff_to_agent_name",
+            "handoffToAgentName",
+            "target_agent_name",
+            "targetAgentName",
+            "agent_name",
+            "agentName",
+        ]) ??
+        nonEmptyString(item.agentName);
+    if (!hasActorValue(requesterAgentId, requesterAgentName) && hasActorValue(executorAgentId, executorAgentName)) {
+        requesterAgentId = executorAgentId;
+        requesterAgentName = executorAgentName;
+    }
+    const unchanged = nonEmptyString(item.requesterAgentId) === requesterAgentId &&
+        nonEmptyString(item.requesterAgentName) === requesterAgentName &&
+        nonEmptyString(item.executorAgentId) === executorAgentId &&
+        nonEmptyString(item.executorAgentName) === executorAgentName;
+    if (unchanged)
+        return item;
+    return {
+        ...item,
+        requesterAgentId: requesterAgentId ?? null,
+        requesterAgentName: requesterAgentName ?? null,
+        executorAgentId: executorAgentId ?? null,
+        executorAgentName: executorAgentName ?? null,
+    };
+}
+export function enrichActivityActorFieldsList(items) {
+    if (!Array.isArray(items) || items.length === 0)
+        return [];
+    return items.map((item) => enrichActivityActorFields(item));
+}

package/dist/activity-store.d.ts

@@ -0,0 +1,28 @@
+import type { LiveActivityItem } from "./contracts/types.js";
+export type ActivityPageCursor = {
+    beforeEpoch: number;
+    beforeId: string;
+};
+export type ListActivityPageParams = {
+    limit: number;
+    runId?: string | null;
+    since?: string | null;
+    until?: string | null;
+    cursor?: string | null;
+};
+export type ListActivityPageResult = {
+    activities: LiveActivityItem[];
+    nextCursor: string | null;
+    total: number;
+    storeUpdatedAt: string;
+};
+export declare function appendActivityItems(items: LiveActivityItem[]): {
+    appended: number;
+    updated: number;
+    total: number;
+};
+export declare function listActivityPage(params: ListActivityPageParams): ListActivityPageResult;
+export declare function getActivityStoreStats(): {
+    total: number;
+    updatedAt: string;
+};

package/dist/activity-store.js

@@ -0,0 +1,257 @@
+import { chmodSync, existsSync, mkdirSync, readFileSync, } from "node:fs";
+import { Buffer } from "node:buffer";
+import { enrichActivityActorFieldsList } from "./activity-actor-fields.js";
+import { getOrgxPluginConfigDir, getOrgxPluginConfigPath } from "./paths.js";
+import { backupCorruptFileSync, writeJsonFileAtomicSync } from "./fs-utils.js";
+const STORE_VERSION = 1;
+const STORE_FILENAME = "activity-store.json";
+const MAX_ITEMS = 50_000;
+const RETENTION_DAYS = 45;
+const FLUSH_DEBOUNCE_MS = 1_250;
+let cached = null;
+function ensureDir() {
+    const dir = getOrgxPluginConfigDir();
+    mkdirSync(dir, { recursive: true, mode: 0o700 });
+    try {
+        chmodSync(dir, 0o700);
+    }
+    catch {
+        // best effort
+    }
+}
+function storePath() {
+    return getOrgxPluginConfigPath(STORE_FILENAME);
+}
+function parseJson(value) {
+    try {
+        return JSON.parse(value);
+    }
+    catch {
+        return null;
+    }
+}
+function toEpoch(value) {
+    if (!value)
+        return 0;
+    const parsed = Date.parse(value);
+    return Number.isFinite(parsed) ? parsed : 0;
+}
+function compareActivity(a, b) {
+    const delta = toEpoch(b.timestamp) - toEpoch(a.timestamp);
+    if (delta !== 0)
+        return delta;
+    // Deterministic tie-breaker for cursor paging.
+    return String(b.id).localeCompare(String(a.id));
+}
+function normalizeItems(source) {
+    const now = Date.now();
+    const cutoffEpoch = now - RETENTION_DAYS * 24 * 60 * 60_000;
+    const byId = new Map();
+    for (const item of source) {
+        if (!item || typeof item !== "object")
+            continue;
+        if (typeof item.id !== "string")
+            continue;
+        const id = item.id.trim();
+        if (!id)
+            continue;
+        const ts = typeof item.timestamp === "string" ? item.timestamp : null;
+        const epoch = toEpoch(ts);
+        if (!epoch)
+            continue;
+        if (epoch < cutoffEpoch)
+            continue;
+        byId.set(id, item);
+    }
+    return enrichActivityActorFieldsList(Array.from(byId.values()))
+        .sort(compareActivity)
+        .slice(0, MAX_ITEMS);
+}
+function readPersistedStore() {
+    ensureDir();
+    const file = storePath();
+    if (!existsSync(file)) {
+        return { version: STORE_VERSION, updatedAt: new Date().toISOString(), items: [] };
+    }
+    try {
+        const raw = readFileSync(file, "utf8");
+        const parsed = parseJson(raw);
+        if (!parsed || parsed.version !== STORE_VERSION || !Array.isArray(parsed.items)) {
+            backupCorruptFileSync(file);
+            return { version: STORE_VERSION, updatedAt: new Date().toISOString(), items: [] };
+        }
+        return {
+            version: STORE_VERSION,
+            updatedAt: typeof parsed.updatedAt === "string" ? parsed.updatedAt : new Date().toISOString(),
+            items: normalizeItems(parsed.items),
+        };
+    }
+    catch {
+        return { version: STORE_VERSION, updatedAt: new Date().toISOString(), items: [] };
+    }
+}
+function ensureCache() {
+    if (cached)
+        return cached;
+    const persisted = readPersistedStore();
+    const byId = new Map();
+    for (const item of persisted.items) {
+        byId.set(item.id, item);
+    }
+    cached = {
+        storeUpdatedAt: persisted.updatedAt,
+        items: persisted.items,
+        byId,
+        dirty: false,
+        flushTimer: null,
+    };
+    return cached;
+}
+function encodeCursor(cursor) {
+    const payload = JSON.stringify(cursor);
+    return Buffer.from(payload, "utf8")
+        .toString("base64")
+        .replaceAll("+", "-")
+        .replaceAll("/", "_")
+        .replaceAll("=", "");
+}
+function decodeCursor(raw) {
+    const value = (raw ?? "").trim();
+    if (!value)
+        return null;
+    try {
+        const padded = value.replaceAll("-", "+").replaceAll("_", "/") + "===".slice((value.length + 3) % 4);
+        const decoded = Buffer.from(padded, "base64").toString("utf8");
+        const parsed = JSON.parse(decoded);
+        if (!parsed || typeof parsed !== "object")
+            return null;
+        if (!Number.isFinite(parsed.beforeEpoch))
+            return null;
+        if (typeof parsed.beforeId !== "string" || !parsed.beforeId.trim())
+            return null;
+        return { beforeEpoch: parsed.beforeEpoch, beforeId: parsed.beforeId.trim() };
+    }
+    catch {
+        return null;
+    }
+}
+function scheduleFlush(state) {
+    if (!state.dirty)
+        return;
+    if (state.flushTimer)
+        return;
+    state.flushTimer = setTimeout(() => {
+        state.flushTimer = null;
+        if (!state.dirty)
+            return;
+        state.dirty = false;
+        state.storeUpdatedAt = new Date().toISOString();
+        const payload = {
+            version: STORE_VERSION,
+            updatedAt: state.storeUpdatedAt,
+            items: state.items,
+        };
+        writeJsonFileAtomicSync(storePath(), payload, 0o600);
+    }, FLUSH_DEBOUNCE_MS);
+    state.flushTimer.unref?.();
+}
+export function appendActivityItems(items) {
+    if (!Array.isArray(items) || items.length === 0) {
+        const state = ensureCache();
+        return { appended: 0, updated: 0, total: state.items.length };
+    }
+    const state = ensureCache();
+    let appended = 0;
+    let updated = 0;
+    for (const item of items) {
+        if (!item || typeof item !== "object")
+            continue;
+        if (typeof item.id !== "string" || !item.id.trim())
+            continue;
+        if (typeof item.timestamp !== "string" || !item.timestamp.trim())
+            continue;
+        if (!Number.isFinite(Date.parse(item.timestamp)))
+            continue;
+        const id = item.id.trim();
+        const existing = state.byId.get(id);
+        if (!existing) {
+            state.byId.set(id, item);
+            appended += 1;
+            continue;
+        }
+        // Replace if any key fields differ; metadata/summary changes are real updates.
+        if (existing.timestamp !== item.timestamp ||
+            existing.type !== item.type ||
+            existing.title !== item.title ||
+            existing.description !== item.description ||
+            (existing.requesterAgentId ?? null) !== (item.requesterAgentId ?? null) ||
+            (existing.requesterAgentName ?? null) !== (item.requesterAgentName ?? null) ||
+            (existing.executorAgentId ?? null) !== (item.executorAgentId ?? null) ||
+            (existing.executorAgentName ?? null) !== (item.executorAgentName ?? null) ||
+            existing.summary !== item.summary ||
+            JSON.stringify(existing.metadata ?? null) !== JSON.stringify(item.metadata ?? null)) {
+            state.byId.set(id, item);
+            updated += 1;
+        }
+    }
+    if (appended === 0 && updated === 0) {
+        return { appended: 0, updated: 0, total: state.items.length };
+    }
+    // Rebuild sorted list from map. This is O(n) but bounded by MAX_ITEMS.
+    state.items = normalizeItems(Array.from(state.byId.values()));
+    state.byId = new Map(state.items.map((item) => [item.id, item]));
+    state.dirty = true;
+    scheduleFlush(state);
+    return { appended, updated, total: state.items.length };
+}
+export function listActivityPage(params) {
+    const state = ensureCache();
+    const limit = Math.max(1, Math.min(500, Math.floor(params.limit || 100)));
+    const runId = typeof params.runId === "string" && params.runId.trim() ? params.runId.trim() : null;
+    const sinceEpoch = params.since ? toEpoch(params.since) : 0;
+    const untilEpoch = params.until ? toEpoch(params.until) : 0;
+    const cursor = decodeCursor(params.cursor ?? null);
+    const filtered = [];
+    for (const item of state.items) {
+        const epoch = toEpoch(item.timestamp);
+        if (!epoch)
+            continue;
+        if (sinceEpoch && epoch < sinceEpoch)
+            continue;
+        if (untilEpoch && epoch > untilEpoch)
+            continue;
+        if (runId) {
+            const matchRunId = item.runId ?? item.metadata?.runId ?? null;
+            if (matchRunId !== runId)
+                continue;
+        }
+        if (cursor) {
+            if (epoch > cursor.beforeEpoch)
+                continue;
+            if (epoch === cursor.beforeEpoch && String(item.id) >= cursor.beforeId)
+                continue;
+        }
+        filtered.push(item);
+        if (filtered.length >= limit)
+            break;
+    }
+    // Determine next cursor by checking if there is at least one more matching item after the last.
+    let nextCursor = null;
+    if (filtered.length === limit) {
+        const last = filtered[filtered.length - 1];
+        const beforeEpoch = toEpoch(last.timestamp);
+        if (beforeEpoch) {
+            nextCursor = encodeCursor({ beforeEpoch, beforeId: String(last.id) });
+        }
+    }
+    return {
+        activities: filtered,
+        nextCursor,
+        total: state.items.length,
+        storeUpdatedAt: state.storeUpdatedAt,
+    };
+}
+export function getActivityStoreStats() {
+    const state = ensureCache();
+    return { total: state.items.length, updatedAt: state.storeUpdatedAt };
+}

package/dist/agent-context-store.d.ts

@@ -6,12 +6,23 @@ export type AgentLaunchContext = {
     taskId: string | null;
     updatedAt: string;
 };
+export type RunLaunchContext = {
+    runId: string;
+    agentId: string;
+    initiativeId: string | null;
+    initiativeTitle: string | null;
+    workstreamId: string | null;
+    taskId: string | null;
+    updatedAt: string;
+};
 type PersistedAgentContexts = {
     updatedAt: string;
     agents: Record<string, AgentLaunchContext>;
+    runs?: Record<string, RunLaunchContext>;
 };
 export declare function readAgentContexts(): PersistedAgentContexts;
 export declare function getAgentContext(agentId: string): AgentLaunchContext | null;
+export declare function getRunContext(runId: string): RunLaunchContext | null;
 export declare function upsertAgentContext(input: {
     agentId: string;
     initiativeId?: string | null;
@@ -19,5 +30,13 @@ export declare function upsertAgentContext(input: {
     workstreamId?: string | null;
     taskId?: string | null;
 }): PersistedAgentContexts;
+export declare function upsertRunContext(input: {
+    runId: string;
+    agentId: string;
+    initiativeId?: string | null;
+    initiativeTitle?: string | null;
+    workstreamId?: string | null;
+    taskId?: string | null;
+}): PersistedAgentContexts;
 export declare function clearAgentContexts(): void;
 export {};

package/dist/agent-context-store.js

@@ -2,6 +2,7 @@ import { chmodSync, existsSync, mkdirSync, readFileSync, rmSync, } from "node:fs
 import { getOrgxPluginConfigDir, getOrgxPluginConfigPath } from "./paths.js";
 import { backupCorruptFileSync, writeJsonFileAtomicSync } from "./fs-utils.js";
 const MAX_AGENTS = 120;
+const MAX_RUNS = 480;
 function contextDir() {
     return getOrgxPluginConfigDir();
 }
@@ -36,28 +37,41 @@ function normalizeContext(input) {
         updatedAt: input.updatedAt,
     };
 }
+function normalizeRunContext(input) {
+    return {
+        runId: input.runId.trim(),
+        agentId: input.agentId.trim(),
+        initiativeId: input.initiativeId ?? null,
+        initiativeTitle: input.initiativeTitle ?? null,
+        workstreamId: input.workstreamId ?? null,
+        taskId: input.taskId ?? null,
+        updatedAt: input.updatedAt,
+    };
+}
 export function readAgentContexts() {
     const file = contextFile();
     try {
         if (!existsSync(file)) {
-            return { updatedAt: new Date().toISOString(), agents: {} };
+            return { updatedAt: new Date().toISOString(), agents: {}, runs: {} };
         }
         const raw = readFileSync(file, "utf8");
         const parsed = parseJson(raw);
         if (!parsed || typeof parsed !== "object") {
             backupCorruptFileSync(file);
-            return { updatedAt: new Date().toISOString(), agents: {} };
+            return { updatedAt: new Date().toISOString(), agents: {}, runs: {} };
         }
         const agents = parsed.agents && typeof parsed.agents === "object" ? parsed.agents : {};
+        const runs = parsed.runs && typeof parsed.runs === "object" ? parsed.runs : {};
         return {
             updatedAt: typeof parsed.updatedAt === "string"
                 ? parsed.updatedAt
                 : new Date().toISOString(),
             agents: agents,
+            runs: runs,
         };
     }
     catch {
-        return { updatedAt: new Date().toISOString(), agents: {} };
+        return { updatedAt: new Date().toISOString(), agents: {}, runs: {} };
     }
 }
 export function getAgentContext(agentId) {
@@ -68,6 +82,14 @@ export function getAgentContext(agentId) {
     const ctx = store.agents[id];
     return ctx ? normalizeContext(ctx) : null;
 }
+export function getRunContext(runId) {
+    const id = runId.trim();
+    if (!id)
+        return null;
+    const store = readAgentContexts();
+    const ctx = store.runs?.[id];
+    return ctx ? normalizeRunContext(ctx) : null;
+}
 export function upsertAgentContext(input) {
     const agentId = input.agentId.trim();
     if (!agentId) {
@@ -99,6 +121,41 @@ export function upsertAgentContext(input) {
     writeJsonFileAtomicSync(file, next, 0o600);
     return next;
 }
+export function upsertRunContext(input) {
+    const runId = input.runId.trim();
+    const agentId = input.agentId.trim();
+    if (!runId || !agentId) {
+        return readAgentContexts();
+    }
+    ensureContextDir();
+    const next = readAgentContexts();
+    if (!next.runs || typeof next.runs !== "object") {
+        next.runs = {};
+    }
+    next.runs[runId] = normalizeRunContext({
+        runId,
+        agentId,
+        initiativeId: input.initiativeId ?? null,
+        initiativeTitle: input.initiativeTitle ?? null,
+        workstreamId: input.workstreamId ?? null,
+        taskId: input.taskId ?? null,
+        updatedAt: new Date().toISOString(),
+    });
+    next.updatedAt = new Date().toISOString();
+    const values = Object.values(next.runs);
+    if (values.length > MAX_RUNS) {
+        values.sort((a, b) => Date.parse(b.updatedAt) - Date.parse(a.updatedAt));
+        const keep = new Set(values.slice(0, MAX_RUNS).map((c) => c.runId));
+        for (const key of Object.keys(next.runs)) {
+            if (!keep.has(key)) {
+                delete next.runs[key];
+            }
+        }
+    }
+    const file = contextFile();
+    writeJsonFileAtomicSync(file, next, 0o600);
+    return next;
+}
 export function clearAgentContexts() {
     const file = contextFile();
     try {

package/dist/agent-suite.d.ts

@@ -0,0 +1,83 @@
+export type OrgxSuiteDomain = "engineering" | "product" | "design" | "marketing" | "sales" | "operations" | "orchestration";
+export type OrgxSuiteAgentSpec = {
+    id: string;
+    name: string;
+    domain: OrgxSuiteDomain;
+};
+export declare const ORGX_AGENT_SUITE_PACK_ID = "orgx-agent-suite";
+export declare const ORGX_AGENT_SUITE_AGENTS: OrgxSuiteAgentSpec[];
+declare const SUITE_FILES: readonly ["AGENTS.md", "TOOLS.md", "IDENTITY.md", "SKILL.md", "SOUL.md", "USER.md", "HEARTBEAT.md"];
+export type OrgxSkillPackOverrides = {
+    source: "builtin" | "server";
+    name: string;
+    version: string;
+    checksum: string;
+    etag?: string | null;
+    updated_at?: string | null;
+    openclaw_skills: Partial<Record<OrgxSuiteDomain, string>>;
+};
+export type OrgxAgentSuiteStatus = {
+    packId: string;
+    packVersion: string;
+    openclawConfigPath: string;
+    suiteWorkspaceRoot: string;
+    skillPack?: {
+        source: "builtin" | "server";
+        name: string;
+        version: string;
+        checksum: string;
+        etag?: string | null;
+        updated_at?: string | null;
+    } | null;
+    skillPackRemote?: {
+        name: string;
+        version: string;
+        checksum: string;
+        updated_at?: string | null;
+    } | null;
+    skillPackPolicy?: {
+        frozen: boolean;
+        pinnedChecksum: string | null;
+    } | null;
+    skillPackUpdateAvailable?: boolean;
+    agents: Array<{
+        id: string;
+        name: string;
+        domain: OrgxSuiteDomain;
+        workspace: string;
+        configuredInOpenclaw: boolean;
+        workspaceExists: boolean;
+    }>;
+};
+export type OrgxAgentSuitePlan = OrgxAgentSuiteStatus & {
+    openclawConfigWouldUpdate: boolean;
+    openclawConfigAddedAgents: string[];
+    workspaceFiles: Array<{
+        agentId: string;
+        file: typeof SUITE_FILES[number];
+        managedPath: string;
+        localPath: string;
+        compositePath: string;
+        action: "create" | "update" | "noop" | "conflict";
+    }>;
+};
+export declare function computeOrgxAgentSuitePlan(input: {
+    packVersion: string;
+    openclawDir?: string;
+    skillPack?: OrgxSkillPackOverrides | null;
+    skillPackRemote?: OrgxAgentSuiteStatus["skillPackRemote"] | null;
+    skillPackPolicy?: OrgxAgentSuiteStatus["skillPackPolicy"] | null;
+    skillPackUpdateAvailable?: boolean;
+}): OrgxAgentSuitePlan;
+export declare function applyOrgxAgentSuitePlan(input: {
+    plan: OrgxAgentSuitePlan;
+    dryRun?: boolean;
+    openclawDir?: string;
+    skillPack?: OrgxSkillPackOverrides | null;
+}): {
+    ok: true;
+    applied: boolean;
+    plan: OrgxAgentSuitePlan;
+};
+export declare function generateAgentSuiteOperationId(): string;
+export {};