adp-openclaw 0.0.54 → 0.0.56

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "adp-openclaw",
-  "version": "0.0.54",
+  "version": "0.0.56",
   "description": "ADP-OpenClaw demo channel plugin (Go WebSocket backend)",
   "type": "module",
   "dependencies": {

package/src/adp-upload-tool.ts

@@ -68,7 +68,7 @@ interface FileMetadata {
 // ==================== 常量配置 ====================
 
 /** 获取临时密钥的接口地址 */
-const CREDENTIAL_API_URL = "https://wss.lke.cloud.tencent.com/v1/gateway/storage/get_credential";
+const CREDENTIAL_API_URL = "https://wss.lke.cloud.tencent.com/test/openclaw/v1/gateway/storage/get_credential";
 
 /** 请求超时时间 (毫秒) */
 const REQUEST_TIMEOUT_MS = 30000;

package/src/monitor.ts

@@ -23,6 +23,7 @@ import {
   formatUploadResultAsMarkdown,
 } from "./tool-result-message-blocks.js";
 import crypto from "crypto";
+import fs from "fs";
 // @ts-ignore - import JSON file
 import packageJson from "../package.json" with { type: "json" };
 
@@ -59,6 +60,8 @@ const MsgType = {
   // OpenClaw sessions list
   FetchOpenClawSessions: "fetch_openclaw_sessions",
   OpenClawSessionsResponse: "openclaw_sessions_response",
+  // Cancel generation
+  Cancel: "cancel",                        // Server → Client: cancel ongoing generation
 } as const;
 
 type WSMessage = {
@@ -114,6 +117,53 @@ function generateRequestId(): string {
   return `req-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
 }
 
+/**
+ * Mark a session's abortedLastRun flag in the sessions store.
+ * This tells the SDK to inject an "abort hint" on the next message,
+ * preventing the AI from resuming the cancelled task.
+ */
+async function markSessionAborted(params: {
+  sessionKey: string;
+  runtime: ReturnType<typeof getAdpOpenclawRuntime>;
+  cfg?: ClawdbotConfig;
+  log?: PluginLogger;
+}): Promise<void> {
+  const { sessionKey, runtime, cfg, log } = params;
+  try {
+    // Use SDK's resolveStorePath to find the sessions.json location
+    const storePath = runtime.channel.session.resolveStorePath(cfg?.session?.store);
+    if (!storePath || !fs.existsSync(storePath)) {
+      log?.warn?.(`[adp-openclaw] Cannot mark session aborted: store not found at ${storePath}`);
+      return;
+    }
+
+    const raw = fs.readFileSync(storePath, "utf-8");
+    const store = JSON.parse(raw) as Record<string, { abortedLastRun?: boolean; updatedAt?: number; [key: string]: unknown }>;
+
+    // Try both the raw sessionKey and the "agent:main:{sessionKey}" variant
+    const candidates = [sessionKey, `agent:main:${sessionKey}`];
+    let matchedKey: string | undefined;
+    for (const key of candidates) {
+      if (store[key]) {
+        matchedKey = key;
+        break;
+      }
+    }
+
+    if (!matchedKey) {
+      log?.info?.(`[adp-openclaw] Session key not found in store for abort marking: ${sessionKey}`);
+      return;
+    }
+
+    store[matchedKey].abortedLastRun = true;
+    store[matchedKey].updatedAt = Date.now();
+    fs.writeFileSync(storePath, JSON.stringify(store, null, 2), "utf-8");
+    log?.info?.(`[adp-openclaw] Marked session ${matchedKey} as abortedLastRun=true`);
+  } catch (err) {
+    log?.error?.(`[adp-openclaw] Failed to mark session aborted: ${err}`);
+  }
+}
+
 export async function monitorAdpOpenclaw(params: MonitorParams): Promise<void> {
   const { wsUrl, clientToken, signKey, abortSignal, log, cfg } = params;
   const runtime = getAdpOpenclawRuntime();
@@ -167,6 +217,9 @@ async function connectAndHandle(params: ConnectParams): Promise<void> {
     let authenticated = false;
     let pingInterval: NodeJS.Timeout | null = null;
 
+    // Track active generations for cancel support (keyed by conversationId)
+    const activeGenerations = new Map<string, AbortController>();
+
     // Handle abort signal
     const abortHandler = () => {
       ws.close();
@@ -250,6 +303,7 @@ async function connectAndHandle(params: ConnectParams): Promise<void> {
             log?.info(`[adp-openclaw] Received: ${inMsg.from}: ${inMsg.text} (conv=${inMsg.conversationId}, rec=${inMsg.recordId || 'none'}, user=${JSON.stringify(inMsg.user || {})})`);
 
             // Process the message with full user identity
+            const convIdForCleanup = inMsg.conversationId || `fallback-${Date.now()}`;
             try {
               // Build user identity string for From field (like Feishu: "feishu:user_id")
               const userIdentifier = inMsg.user?.userId || inMsg.from;
@@ -330,6 +384,9 @@ async function connectAndHandle(params: ConnectParams): Promise<void> {
                 Timestamp: inMsg.timestamp || Date.now(),
                 OriginatingChannel: "adp-openclaw",
                 OriginatingTo: "adp-openclaw:bot",
+                // Authorize slash commands (/new, /status, /reset, etc.)
+                // Without this, commands are silently dropped (deny-by-default)
+                CommandAuthorized: true,
                 // Pass user metadata through context (like Feishu does)
                 ...userMetadata,
               });
@@ -340,6 +397,15 @@ async function connectAndHandle(params: ConnectParams): Promise<void> {
               let lastPartialText = ""; // Track last sent text for delta calculation
               let finalSent = false; // Track if outbound_end has been sent
               const displayName = inMsg.user?.username || inMsg.from;
+
+              // Per-message AbortController for cancel support
+              const generationController = new AbortController();
+              const convId = inMsg.conversationId || streamId;
+              // Cancel any previous generation for the same conversation
+              if (activeGenerations.has(convId)) {
+                activeGenerations.get(convId)!.abort();
+              }
+              activeGenerations.set(convId, generationController);
               
               // 收集上传结果，在发送最终回复时追加完整的下载链接
               let pendingUploadResults: AdpUploadToolResult[] = [];
@@ -427,6 +493,7 @@ async function connectAndHandle(params: ConnectParams): Promise<void> {
                 // Enable block streaming for SSE support
                 replyOptions: {
                   disableBlockStreaming: false, // Force enable block streaming
+                  abortSignal: generationController.signal, // Per-message cancel support
                   // Use onPartialReply for real-time streaming (character-level)
                   // onPartialReply receives cumulative text, so we need to calculate delta
                   onPartialReply: async (payload: { text?: string }) => {
@@ -556,6 +623,25 @@ async function connectAndHandle(params: ConnectParams): Promise<void> {
               
               log?.info(`[adp-openclaw] dispatchReplyWithBufferedBlockDispatcher returned (finalSent=${finalSent}, chunkIndex=${chunkIndex})`);
               
+              // Clean up active generation tracking
+              activeGenerations.delete(convId);
+
+              // If generation was cancelled (aborted), send outbound_end with partial text
+              if (generationController.signal.aborted && !finalSent) {
+                const cancelText = lastPartialText ? `${lastPartialText}\n\n[已停止生成]` : "[已停止生成]";
+                log?.info(`[adp-openclaw] Generation cancelled, sending outbound_end with partial text`);
+                sendOutboundEnd(cancelText);
+
+                // Mark the session as aborted so the SDK injects an "abort hint"
+                // on the next message, preventing the AI from resuming the cancelled task
+                await markSessionAborted({
+                  sessionKey: route.sessionKey,
+                  runtime,
+                  cfg,
+                  log,
+                });
+              }
+
               // IMPORTANT: After dispatchReplyWithBufferedBlockDispatcher completes,
               // ensure outbound_end is sent even if "final" deliver was not called.
               // This handles cases where the SDK only sends blocks without a final callback.
@@ -566,6 +652,8 @@ async function connectAndHandle(params: ConnectParams): Promise<void> {
                 sendOutboundEnd(finalText);
               }
             } catch (err) {
+              // Clean up on error
+              activeGenerations.delete(convIdForCleanup);
               log?.error(`[adp-openclaw] Failed to process message: ${err}`);
             }
             break;
@@ -582,6 +670,30 @@ async function connectAndHandle(params: ConnectParams): Promise<void> {
             break;
           }
 
+          // Handle cancel generation request from server (user clicked "stop generating")
+          case MsgType.Cancel: {
+            if (!authenticated) break;
+            const cancelPayload = msg.payload as { conversationId?: string; streamId?: string };
+            const cancelConvId = cancelPayload.conversationId || cancelPayload.streamId;
+            log?.info(`[adp-openclaw] Received cancel request for conv=${cancelConvId}`);
+            
+            if (cancelConvId && activeGenerations.has(cancelConvId)) {
+              activeGenerations.get(cancelConvId)!.abort();
+              log?.info(`[adp-openclaw] Generation cancelled for conv=${cancelConvId}`);
+            } else {
+              // If no specific convId, cancel all active generations
+              if (!cancelConvId && activeGenerations.size > 0) {
+                for (const [id, controller] of activeGenerations) {
+                  controller.abort();
+                  log?.info(`[adp-openclaw] Generation cancelled for conv=${id} (cancel-all)`);
+                }
+              } else {
+                log?.warn(`[adp-openclaw] No active generation found for conv=${cancelConvId}`);
+              }
+            }
+            break;
+          }
+
           // Handle fetch OpenClaw chat history request from GoServer
           case MsgType.ConvHistory: {
             if (!authenticated) break;

package/src/session-history.ts

@@ -518,69 +518,6 @@ function findOpenClawCli(config: SessionFileConfig): string | null {
   return null;
 }
 
-/**
- * Extract valid JSON from CLI output that may contain TUI decoration characters
- * (e.g. │, ◇, ◆, spinner frames) mixed into stdout.
- */
-function extractJsonFromOutput(raw: string): string {
-  const trimmed = raw.trim();
-
-  // Fast path: already valid JSON
-  if (
-    (trimmed.startsWith("{") && trimmed.endsWith("}")) ||
-    (trimmed.startsWith("[") && trimmed.endsWith("]"))
-  ) {
-    return trimmed;
-  }
-
-  // Try to find the first top-level JSON object or array in the output
-  const jsonStart = trimmed.search(/[\[{]/);
-  if (jsonStart === -1) {
-    return trimmed; // no JSON-like content, return as-is and let caller handle the error
-  }
-
-  const opener = trimmed[jsonStart];
-  const closer = opener === "{" ? "}" : "]";
-
-  // Walk forward tracking brace/bracket depth to find the matching close
-  let depth = 0;
-  let inString = false;
-  let escaped = false;
-
-  for (let i = jsonStart; i < trimmed.length; i++) {
-    const ch = trimmed[i];
-
-    if (escaped) {
-      escaped = false;
-      continue;
-    }
-    if (ch === "\\") {
-      if (inString) escaped = true;
-      continue;
-    }
-    if (ch === '"') {
-      inString = !inString;
-      continue;
-    }
-    if (inString) continue;
-
-    if (ch === opener || ch === (opener === "{" ? "[" : "{")) {
-      // count both kinds of nesting
-      if (ch === "{" || ch === "[") depth++;
-    }
-    if (ch === closer || ch === (closer === "}" ? "]" : "}")) {
-      if (ch === "}" || ch === "]") depth--;
-    }
-
-    if (depth === 0) {
-      return trimmed.slice(jsonStart, i + 1);
-    }
-  }
-
-  // Fallback: return from jsonStart onwards
-  return trimmed.slice(jsonStart);
-}
-
 /**
  * Execute an openclaw CLI command and return the result.
  * @param subcommands - Array of subcommands, e.g. ["gateway", "call", "chat.history"] or ["sessions"]
@@ -656,7 +593,7 @@ async function executeClawCommand(
         log?.error?.(`[session-history] CLI exited with code ${code}: ${stderr}`);
         reject(new Error(`CLI exited with code ${code}: ${stderr}`));
       } else {
-        resolve(extractJsonFromOutput(stdout));
+        resolve(stdout);
       }
     });
   });