@useorgx/openclaw-plugin 0.4.8 → 0.7.0

package/dist/team-context-store.js

@@ -0,0 +1,116 @@
+/**
+ * Team Context Store — Local cache for cross-agent awareness.
+ *
+ * Persists recent slice completions and decisions per initiative so the
+ * auto-continue engine can provide degraded team context when the server
+ * is unreachable (offline fallback for KickoffContext.team_context).
+ *
+ * Follows the same patterns as agent-context-store.ts: bounded store,
+ * atomic writes, corrupt file recovery.
+ */
+import { existsSync, readFileSync } from "node:fs";
+import { getOrgxPluginConfigDir, getOrgxPluginConfigPath } from "./paths.js";
+import { backupCorruptFileSync, writeJsonFileAtomicSync } from "./fs-utils.js";
+import { clearStoreFileSync, ensureStoreDirSync, parseJsonSafe, } from "./stores/json-store.js";
+const MAX_COMPLETIONS = 20;
+const MAX_DECISIONS = 20;
+const MAX_INITIATIVES = 50;
+function storeDir() {
+    return getOrgxPluginConfigDir();
+}
+function storeFile() {
+    return getOrgxPluginConfigPath("team-context.json");
+}
+function emptyContext() {
+    return { updatedAt: new Date().toISOString(), recent_completions: [], recent_decisions: [] };
+}
+function emptyIndex() {
+    return { initiatives: {} };
+}
+function isValidIndex(value) {
+    if (!value || typeof value !== "object")
+        return false;
+    const record = value;
+    return record.initiatives !== undefined && typeof record.initiatives === "object";
+}
+function readIndex() {
+    const file = storeFile();
+    try {
+        if (!existsSync(file))
+            return emptyIndex();
+        const raw = readFileSync(file, "utf8");
+        const parsed = parseJsonSafe(raw);
+        if (!isValidIndex(parsed)) {
+            backupCorruptFileSync(file);
+            return emptyIndex();
+        }
+        return parsed;
+    }
+    catch {
+        return emptyIndex();
+    }
+}
+function writeIndex(index) {
+    ensureStoreDirSync(storeDir());
+    // Prune if too many initiatives.
+    const keys = Object.keys(index.initiatives);
+    if (keys.length > MAX_INITIATIVES) {
+        const sorted = keys
+            .map((k) => ({ key: k, updatedAt: index.initiatives[k]?.updatedAt ?? "" }))
+            .sort((a, b) => b.updatedAt.localeCompare(a.updatedAt));
+        const keep = new Set(sorted.slice(0, MAX_INITIATIVES).map((e) => e.key));
+        for (const key of keys) {
+            if (!keep.has(key))
+                delete index.initiatives[key];
+        }
+    }
+    writeJsonFileAtomicSync(storeFile(), index, 0o600);
+}
+export function readTeamContext(initiativeId) {
+    const id = initiativeId.trim();
+    if (!id)
+        return emptyContext();
+    const index = readIndex();
+    const ctx = index.initiatives[id];
+    return ctx ?? emptyContext();
+}
+export function appendTeamCompletion(initiativeId, completion) {
+    const id = initiativeId.trim();
+    if (!id)
+        return;
+    const index = readIndex();
+    const ctx = index.initiatives[id] ?? emptyContext();
+    ctx.recent_completions.push(completion);
+    if (ctx.recent_completions.length > MAX_COMPLETIONS) {
+        ctx.recent_completions = ctx.recent_completions.slice(-MAX_COMPLETIONS);
+    }
+    ctx.updatedAt = new Date().toISOString();
+    index.initiatives[id] = ctx;
+    writeIndex(index);
+}
+export function appendTeamDecision(initiativeId, decision) {
+    const id = initiativeId.trim();
+    if (!id)
+        return;
+    const index = readIndex();
+    const ctx = index.initiatives[id] ?? emptyContext();
+    ctx.recent_decisions.push(decision);
+    if (ctx.recent_decisions.length > MAX_DECISIONS) {
+        ctx.recent_decisions = ctx.recent_decisions.slice(-MAX_DECISIONS);
+    }
+    ctx.updatedAt = new Date().toISOString();
+    index.initiatives[id] = ctx;
+    writeIndex(index);
+}
+export function clearTeamContext(initiativeId) {
+    if (!initiativeId) {
+        clearStoreFileSync(storeFile());
+        return;
+    }
+    const id = initiativeId.trim();
+    if (!id)
+        return;
+    const index = readIndex();
+    delete index.initiatives[id];
+    writeIndex(index);
+}

package/dist/telemetry/posthog.js

@@ -1,4 +1,3 @@
-const POSTHOG_DEFAULT_API_KEY = "phc_s4KPgkYEFZgvkMYw4zXG41H5FN6haVwbEWPYHfNjxOc";
 const POSTHOG_DEFAULT_HOST = "https://us.i.posthog.com";
 function isTruthyEnv(value) {
     if (!value)
@@ -15,6 +14,9 @@ function isTruthyEnv(value) {
     }
 }
 export function isOrgxTelemetryDisabled() {
+    const explicitEnable = isTruthyEnv(process.env.ORGX_TELEMETRY_ENABLED);
+    if (!explicitEnable)
+        return true;
     return (isTruthyEnv(process.env.ORGX_TELEMETRY_DISABLED) ||
         isTruthyEnv(process.env.OPENCLAW_TELEMETRY_DISABLED) ||
         isTruthyEnv(process.env.POSTHOG_DISABLED));
@@ -28,7 +30,7 @@ export function resolvePosthogApiKey() {
     const trimmed = fromEnv.trim();
     if (trimmed)
         return trimmed;
-    return POSTHOG_DEFAULT_API_KEY;
+    return null;
 }
 export function resolvePosthogHost() {
     const fromEnv = process.env.ORGX_POSTHOG_HOST ??

package/dist/tools/core-tools.d.ts

@@ -0,0 +1,72 @@
+import type { OrgXClient } from "../api.js";
+import type { AutoAssignedAgent } from "../entities/auto-assignment.js";
+import type { RegisteredTool } from "../mcp-http-handler.js";
+import type { OrgSnapshot, ReportingPhase, ReportingSourceClient } from "../types.js";
+export interface ToolResult {
+    content: Array<{
+        type: "text";
+        text: string;
+    }>;
+}
+export type RegisterToolFn = (tool: {
+    name: string;
+    description: string;
+    parameters: Record<string, unknown>;
+    execute: (callId: string, params?: any) => Promise<ToolResult>;
+}, options?: {
+    optional?: boolean;
+}) => void;
+export interface RegisterCoreToolsDeps {
+    registerTool: RegisterToolFn;
+    client: OrgXClient;
+    config: {
+        syncIntervalMs: number;
+        pluginVersion?: string | null;
+    };
+    getCachedSnapshot: () => OrgSnapshot | null;
+    getLastSnapshotAt: () => number;
+    doSync: () => Promise<void>;
+    text: (value: string) => ToolResult;
+    json: (label: string, data: unknown) => ToolResult;
+    formatSnapshot: (snapshot: OrgSnapshot) => string;
+    autoAssignEntityForCreate: (input: {
+        entityType: string;
+        entityId: string;
+        initiativeId: string | null;
+        title: string;
+        summary: string | null;
+    }) => Promise<{
+        updatedEntity?: unknown;
+        assignmentSource: "orchestrator" | "fallback" | "manual";
+        assignedAgents: AutoAssignedAgent[];
+        warnings: string[];
+    }>;
+    toReportingPhase: (phase: string, progressPct?: number) => ReportingPhase;
+    inferReportingInitiativeId: (input: Record<string, unknown>) => string | undefined;
+    isUuid: (value: string | undefined) => value is string;
+    pickNonEmptyString: (...values: Array<unknown>) => string | undefined;
+    resolveReportingContext: (input: Record<string, unknown>) => {
+        ok: true;
+        value: {
+            initiativeId: string;
+            runId?: string;
+            correlationId?: string;
+            sourceClient?: ReportingSourceClient;
+        };
+    } | {
+        ok: false;
+        error: string;
+    };
+    readSkillPackState: () => import("../skill-pack-state.js").SkillPackState;
+    updateSkillPackPolicy: (input: {
+        frozen?: boolean;
+        pinnedChecksum?: string | null;
+        pinToCurrent?: boolean;
+        clearPin?: boolean;
+    }) => import("../skill-pack-state.js").SkillPackState;
+    rollbackSkillPackPolicy: (input?: {
+        auditId?: string;
+    }) => import("../skill-pack-state.js").SkillPackState;
+    randomUUID?: () => string;
+}
+export declare function registerCoreTools(deps: RegisterCoreToolsDeps): Map<string, RegisteredTool>;