denchclaw 2.0.7 → 2.0.9

package/dist/{program-CfNvnqVx.js → program-BYwTE_Ot.js}

@@ -1342,6 +1342,19 @@ async function installBundledPlugins(params) {
 				errorMessage: "Failed to set posthog-analytics API key."
 			});
 		}
+		try {
+			await runOpenClawOrThrow({
+				openclawCommand: params.openclawCommand,
+				args: [
+					"--profile",
+					params.profile,
+					"gateway",
+					"restart"
+				],
+				timeoutMs: 6e4,
+				errorMessage: "Failed to restart gateway after plugin install."
+			});
+		} catch {}
 		return true;
 	} catch {
 		return false;
@@ -2824,7 +2837,7 @@ function registerTelemetryCommand(program) {
 	cmd.command("disable").description("Disable anonymous telemetry").action(() => {
 		writeTelemetryConfig({ enabled: false });
 		console.log("Telemetry has been disabled.");
-		console.log("You can re-enable it anytime with: denchclaw telemetry enable");
+		console.log("You can re-enable it anytime with: npx denchclaw telemetry enable");
 	});
 	cmd.command("enable").description("Enable anonymous telemetry").action(() => {
 		writeTelemetryConfig({ enabled: true });
@@ -2833,7 +2846,7 @@ function registerTelemetryCommand(program) {
 	const privacyCmd = cmd.command("privacy").description("Control whether message content is included in telemetry");
 	privacyCmd.command("on").description("Enable privacy mode (redacts message content, default)").action(() => {
 		if (!isTelemetryEnabled()) {
-			console.log("Telemetry is currently disabled. Enable it first with: denchclaw telemetry enable");
+			console.log("Telemetry is currently disabled. Enable it first with: npx denchclaw telemetry enable");
 			return;
 		}
 		writeTelemetryConfig({ privacyMode: true });
@@ -2841,12 +2854,12 @@ function registerTelemetryCommand(program) {
 	});
 	privacyCmd.command("off").description("Disable privacy mode (sends full message content)").action(() => {
 		if (!isTelemetryEnabled()) {
-			console.log("Telemetry is currently disabled. Enable it first with: denchclaw telemetry enable");
+			console.log("Telemetry is currently disabled. Enable it first with: npx denchclaw telemetry enable");
 			return;
 		}
 		writeTelemetryConfig({ privacyMode: false });
 		console.log("Privacy mode disabled. Full message content and tool results will be captured.");
-		console.log("Re-enable anytime with: denchclaw telemetry privacy on");
+		console.log("Re-enable anytime with: npx denchclaw telemetry privacy on");
 	});
 }
 

package/dist/{run-main-BWHpVYis.js → run-main-CWe8UBRN.js}

@@ -219,7 +219,7 @@ async function runCli(argv = process$1.argv) {
 		process$1.exitCode = await delegateToGlobalOpenClaw(parseArgv);
 		return;
 	}
-	const { buildProgram } = await import("./program-CfNvnqVx.js");
+	const { buildProgram } = await import("./program-BYwTE_Ot.js");
 	await buildProgram().parseAsync(parseArgv);
 }
 

package/extensions/posthog-analytics/index.ts

@@ -109,7 +109,7 @@ export default function register(api: any) {
       }
 
       emitGeneration(ph, traceCtx, sk, event, getPrivacyMode());
-      emitTrace(ph, traceCtx, sk);
+      emitTrace(ph, traceCtx, sk, event, getPrivacyMode());
       emitCustomEvent(ph, "dench_turn_completed", {
         session_id: sk,
         run_id: ctx.runId,

package/extensions/posthog-analytics/lib/event-mappers.ts

@@ -2,7 +2,7 @@ import { createHash } from "node:crypto";
 import os from "node:os";
 import type { PostHogClient } from "./posthog-client.js";
 import type { TraceContextManager } from "./trace-context.js";
-import { sanitizeForCapture, stripSecrets } from "./privacy.js";
+import { sanitizeMessages, sanitizeOutputChoices, stripSecrets } from "./privacy.js";
 
 function getAnonymousId(): string {
   try {
@@ -15,8 +15,6 @@ function getAnonymousId(): string {
 
 /**
  * Extract actual token counts and cost from OpenClaw's per-message usage metadata.
- * Each assistant message in the agent_end messages array includes:
- *   usage: { input, output, cacheRead, cacheWrite, cost: { total, input, output, ... } }
  */
 export function extractUsageFromMessages(messages: unknown): {
   inputTokens: number;
@@ -52,25 +50,25 @@ export function extractToolNamesFromMessages(messages: unknown): string[] {
     if (!msg || typeof msg !== "object") continue;
     const m = msg as Record<string, unknown>;
 
-    // OpenAI format: assistant message with tool_calls array
     if (Array.isArray(m.tool_calls)) {
       for (const tc of m.tool_calls) {
         const name = (tc as any)?.function?.name ?? (tc as any)?.name;
         if (typeof name === "string" && name) names.push(name);
       }
     }
-    // Anthropic format: content blocks with type "tool_use"
     if (Array.isArray(m.content)) {
       for (const block of m.content) {
         if ((block as any)?.type === "tool_use" && typeof (block as any)?.name === "string") {
           names.push((block as any).name);
         }
+        if ((block as any)?.type === "toolCall" && typeof (block as any)?.name === "string") {
+          names.push((block as any).name);
+        }
         if ((block as any)?.type === "tool-call" && typeof (block as any)?.toolName === "string") {
           names.push((block as any).toolName);
         }
       }
     }
-    // Tool result messages have a "name" field with the tool name
     if (m.role === "tool" && typeof m.name === "string") {
       names.push(m.name);
     }
@@ -81,8 +79,6 @@ export function extractToolNamesFromMessages(messages: unknown): string[] {
 /**
  * Normalize OpenClaw's message format into OpenAI-compatible output choices
  * so PostHog can extract tool calls for the Tools tab.
- * Converts Anthropic-style content blocks (type: "toolCall") to OpenAI's
- * tool_calls array format.
  */
 export function normalizeOutputForPostHog(messages: unknown): unknown[] | undefined {
   if (!Array.isArray(messages)) return undefined;
@@ -135,6 +131,80 @@ export function normalizeOutputForPostHog(messages: unknown): unknown[] | undefi
   return choices.length > 0 ? choices : undefined;
 }
 
+/**
+ * Build full conversation state for the $ai_trace event.
+ * Splits messages into input (user/tool/system) and output (assistant) arrays,
+ * preserving chronological order so PostHog renders the full conversation.
+ */
+export function buildTraceState(
+  messages: unknown,
+  privacyMode: boolean,
+): { inputState: unknown; outputState: unknown } {
+  if (!Array.isArray(messages)) return { inputState: undefined, outputState: undefined };
+
+  const inputMessages: unknown[] = [];
+  const outputMessages: unknown[] = [];
+
+  for (const msg of messages) {
+    if (!msg || typeof msg !== "object") continue;
+    const m = msg as Record<string, unknown>;
+
+    const extractText = () => {
+      if (Array.isArray(m.content)) {
+        return (m.content as Array<Record<string, unknown>>)
+          .filter((b) => b.type === "text")
+          .map((b) => b.text)
+          .join("");
+      }
+      return typeof m.content === "string" ? m.content : null;
+    };
+
+    if (m.role === "assistant") {
+      const content = privacyMode ? "[REDACTED]" : extractText();
+      const entry: Record<string, unknown> = { role: "assistant", content };
+
+      const toolNames = extractToolNamesFromSingleMessage(m);
+      if (toolNames.length > 0) {
+        entry.tool_calls = toolNames.map((name) => ({
+          type: "function",
+          function: { name },
+        }));
+      }
+
+      outputMessages.push(entry);
+    } else if (m.role === "user" || m.role === "tool" || m.role === "toolResult" || m.role === "system") {
+      const content = privacyMode ? "[REDACTED]" : extractText();
+      const entry: Record<string, unknown> = { role: m.role, content };
+      if (m.name) entry.name = m.name;
+      if (m.toolName) entry.toolName = m.toolName;
+      inputMessages.push(entry);
+    }
+  }
+
+  return {
+    inputState: inputMessages.length > 0 ? inputMessages : undefined,
+    outputState: outputMessages.length > 0 ? outputMessages : undefined,
+  };
+}
+
+function extractToolNamesFromSingleMessage(m: Record<string, unknown>): string[] {
+  const names: string[] = [];
+  if (Array.isArray(m.tool_calls)) {
+    for (const tc of m.tool_calls) {
+      const name = (tc as any)?.function?.name ?? (tc as any)?.name;
+      if (typeof name === "string" && name) names.push(name);
+    }
+  }
+  if (Array.isArray(m.content)) {
+    for (const block of m.content) {
+      if ((block as any)?.type === "toolCall" && typeof (block as any)?.name === "string") {
+        names.push((block as any).name);
+      }
+    }
+  }
+  return names;
+}
+
 /**
  * Emit a `$ai_generation` event from the agent_end hook data.
  */
@@ -187,10 +257,10 @@ export function emitGeneration(
       if (extracted.totalCostUsd > 0) properties.$ai_total_cost_usd = extracted.totalCostUsd;
     }
 
-    properties.$ai_input = sanitizeForCapture(trace.input, privacyMode);
+    properties.$ai_input = sanitizeMessages(trace.input, privacyMode);
 
     const outputChoices = normalizeOutputForPostHog(event.messages);
-    properties.$ai_output_choices = sanitizeForCapture(
+    properties.$ai_output_choices = sanitizeOutputChoices(
       outputChoices ?? event.output ?? event.messages,
       privacyMode,
     );
@@ -264,6 +334,8 @@ export function emitTrace(
   ph: PostHogClient,
   traceCtx: TraceContextManager,
   sessionKey: string,
+  event?: any,
+  privacyMode?: boolean,
 ): void {
   try {
     const trace = traceCtx.getTrace(sessionKey);
@@ -273,6 +345,11 @@ export function emitTrace(
       ? (Date.now() - trace.startedAt) / 1_000
       : undefined;
 
+    const { inputState, outputState } = buildTraceState(
+      event?.messages,
+      privacyMode ?? true,
+    );
+
     ph.capture({
       distinctId: getAnonymousId(),
       event: "$ai_trace",
@@ -281,6 +358,8 @@ export function emitTrace(
         $ai_session_id: trace.sessionId,
         $ai_latency: latency,
         $ai_span_name: "agent_run",
+        $ai_input_state: inputState,
+        $ai_output_state: outputState,
         tool_count: trace.toolSpans.length,
       },
     });

package/extensions/posthog-analytics/lib/privacy.ts

@@ -81,3 +81,138 @@ export function sanitizeForCapture(
   if (privacyMode) return REDACTED;
   return stripSecrets(value);
 }
+
+/**
+ * Redact a tool_calls array while preserving tool name, id, and type metadata.
+ * Only arguments are redacted.
+ */
+function redactToolCalls(toolCalls: unknown[]): unknown[] {
+  return toolCalls.map((tc: any) => {
+    if (!tc || typeof tc !== "object") return tc;
+    const out: Record<string, unknown> = {
+      id: tc.id,
+      type: tc.type ?? "function",
+    };
+    if (tc.function && typeof tc.function === "object") {
+      out.function = {
+        name: tc.function.name,
+        arguments: REDACTED,
+      };
+    }
+    if (tc.name) out.name = tc.name;
+    return out;
+  });
+}
+
+/**
+ * Redact Anthropic-format content blocks while preserving tool metadata.
+ * Text blocks get redacted; toolCall blocks keep their name but redact arguments.
+ */
+function redactContentBlocks(blocks: unknown[]): unknown[] {
+  return blocks.map((block: any) => {
+    if (!block || typeof block !== "object") return block;
+    if (block.type === "text") {
+      return { type: "text", text: REDACTED };
+    }
+    if (block.type === "toolCall") {
+      return {
+        type: "toolCall",
+        id: block.id ?? block.toolCallId,
+        name: block.name,
+        arguments: REDACTED,
+      };
+    }
+    if (block.type === "tool_use") {
+      return {
+        type: "tool_use",
+        id: block.id,
+        name: block.name,
+        input: REDACTED,
+      };
+    }
+    if (block.type === "thinking") {
+      return { type: "thinking", text: REDACTED };
+    }
+    return { type: block.type };
+  });
+}
+
+/**
+ * Structure-preserving message redaction for PostHog message-array fields.
+ * Preserves: role, tool names, tool_call IDs, message ordering, tool types.
+ * Redacts: text content, tool arguments, tool results.
+ */
+export function redactMessagesStructured(messages: unknown): unknown {
+  if (!Array.isArray(messages)) return messages;
+  return messages.map((msg: any) => {
+    if (!msg || typeof msg !== "object") return msg;
+    const out: Record<string, unknown> = { role: msg.role };
+
+    if (msg.name) out.name = msg.name;
+    if (msg.tool_call_id) out.tool_call_id = msg.tool_call_id;
+    if (msg.toolCallId) out.toolCallId = msg.toolCallId;
+    if (msg.toolName) out.toolName = msg.toolName;
+    if (msg.isError != null) out.isError = msg.isError;
+    if (msg.stopReason) out.stopReason = msg.stopReason;
+    if (msg.model) out.model = msg.model;
+    if (msg.provider) out.provider = msg.provider;
+
+    if (Array.isArray(msg.content)) {
+      out.content = redactContentBlocks(msg.content);
+    } else {
+      out.content = REDACTED;
+    }
+
+    if (Array.isArray(msg.tool_calls)) {
+      out.tool_calls = redactToolCalls(msg.tool_calls);
+    }
+
+    return out;
+  });
+}
+
+/**
+ * Structure-preserving redaction for normalized OpenAI-format output choices.
+ * Keeps role, tool_calls[].function.name, tool_calls[].type.
+ * Redacts text content and tool arguments.
+ */
+export function redactOutputChoicesStructured(choices: unknown): unknown {
+  if (!Array.isArray(choices)) return choices;
+  return choices.map((choice: any) => {
+    if (!choice || typeof choice !== "object") return choice;
+    const out: Record<string, unknown> = {
+      role: choice.role,
+      content: choice.content != null ? REDACTED : null,
+    };
+    if (Array.isArray(choice.tool_calls)) {
+      out.tool_calls = redactToolCalls(choice.tool_calls);
+    }
+    return out;
+  });
+}
+
+/**
+ * Sanitize messages for PostHog capture, preserving structure in privacy mode.
+ * Privacy on: redacts text content/arguments but keeps role, tool names, ordering.
+ * Privacy off: only strips credential patterns.
+ */
+export function sanitizeMessages(
+  messages: unknown,
+  privacyMode: boolean,
+): unknown {
+  if (privacyMode) return redactMessagesStructured(messages);
+  return stripSecrets(messages);
+}
+
+/**
+ * Sanitize normalized output choices for PostHog capture, preserving structure.
+ * Privacy on: redacts text content/arguments but keeps role, tool names.
+ * Privacy off: only strips credential patterns.
+ */
+export function sanitizeOutputChoices(
+  choices: unknown,
+  privacyMode: boolean,
+): unknown {
+  if (privacyMode) return redactOutputChoicesStructured(choices);
+  return stripSecrets(choices);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "denchclaw",
-  "version": "2.0.7",
+  "version": "2.0.9",
   "description": "Fully Managed OpenClaw Framework for managing your CRM, Sales Automation and Outreach agents. The only local productivity tool you need.",
   "keywords": [],
   "homepage": "https://github.com/DenchHQ/DenchClaw#readme",