adp-openclaw 0.0.27 → 0.0.29

package/package.json

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

package/src/session-history.ts

@@ -519,18 +519,21 @@ function findOpenClawCli(config: SessionFileConfig): string | null {
 }
 
 /**
- * Execute an openclaw CLI command and return the result
+ * Execute an openclaw CLI command and return the result.
+ * @param subcommands - Array of subcommands, e.g. ["gateway", "call", "chat.history"] or ["sessions"]
+ * @param args - Additional CLI flags, e.g. ["--json", "--params", '{"sessionKey":"main"}']
  */
 async function executeClawCommand(
-  command: string,
+  subcommands: string[],
   args: string[],
   options?: {
     log?: PluginLogger;
     timeout?: number;
     gatewayUrl?: string;
+    gatewayToken?: string;
   },
 ): Promise<string> {
-  const { log, timeout = 30000, gatewayUrl } = options ?? {};
+  const { log, timeout = 30000, gatewayUrl, gatewayToken } = options ?? {};
   
   const cliPath = findOpenClawCli(sessionFileConfig);
   if (!cliPath) {
@@ -540,22 +543,34 @@ async function executeClawCommand(
   // Build command arguments
   const fullArgs = [...args];
   if (gatewayUrl) {
-    fullArgs.unshift("--gateway", gatewayUrl);
+    fullArgs.push("--url", gatewayUrl);
+  }
+  if (gatewayToken) {
+    fullArgs.push("--token", gatewayToken);
   }
   
-  log?.debug?.(`[session-history] Executing: ${cliPath} ${command} ${fullArgs.join(" ")}`);
+  const cmdStr = `${cliPath} ${subcommands.join(" ")} ${fullArgs.join(" ")}`;
+  log?.debug?.(`[session-history] Executing: ${cmdStr}`);
   
   return new Promise((resolve, reject) => {
     const parts = cliPath.split(" ");
     const binary = parts[0];
     const preArgs = parts.slice(1);
     
+    // Ensure node's bin directory is in PATH (fixes nvm/pnpm environments
+    // where the spawned shell may not have node in its PATH)
+    const nodeDir = path.dirname(process.execPath);
+    const currentPath = process.env.PATH || "";
+    const envPath = currentPath.includes(nodeDir)
+      ? currentPath
+      : `${nodeDir}:${currentPath}`;
+
     const spawnOpts: SpawnOptions = {
       timeout,
-      env: { ...process.env },
+      env: { ...process.env, PATH: envPath },
     };
     
-    const child = spawn(binary, [...preArgs, command, ...fullArgs], spawnOpts);
+    const child = spawn(binary, [...preArgs, ...subcommands, ...fullArgs], spawnOpts);
     
     let stdout = "";
     let stderr = "";
@@ -586,7 +601,7 @@ async function executeClawCommand(
 
 /**
  * Get chat history via CLI command
- * Uses: openclaw rpc chat.history --session-key <key> --limit <n>
+ * Uses: openclaw gateway call chat.history --params '{"sessionKey":"<key>","limit":<n>}' --json
  */
 export async function getOpenClawChatHistoryViaCli(
   sessionKey: string = "main",
@@ -601,19 +616,26 @@ export async function getOpenClawChatHistoryViaCli(
   log?.info?.(`[session-history] Fetching chat history via CLI for session: ${sessionKey}`);
   
   try {
-    const args = ["--json"];
+    // Build RPC params object
+    const params: Record<string, unknown> = {};
     if (sessionKey) {
-      args.push("--session-key", sessionKey);
+      params.sessionKey = sessionKey;
     }
     if (limit) {
-      args.push("--limit", String(limit));
+      params.limit = limit;
     }
     
-    // Try using the rpc subcommand
-    const result = await executeClawCommand("rpc", ["chat.history", ...args], {
-      log,
-      gatewayUrl: gatewayUrl || sessionFileConfig.gatewayUrl,
-    });
+    // Use: openclaw gateway call chat.history --params '{...}' --json
+    const args = ["--json", "--params", JSON.stringify(params)];
+    
+    const result = await executeClawCommand(
+      ["gateway", "call", "chat.history"],
+      args,
+      {
+        log,
+        gatewayUrl: gatewayUrl || sessionFileConfig.gatewayUrl,
+      },
+    );
     
     // Parse JSON result
     const parsed = JSON.parse(result) as {
@@ -652,7 +674,8 @@ export async function getOpenClawChatHistoryViaCli(
 
 /**
  * List sessions via CLI command
- * Uses: openclaw rpc sessions.list --limit <n>
+ * Uses: openclaw sessions --json (local, reads session store directly)
+ * Falls back to: openclaw gateway call sessions.list --params '{...}' --json (via Gateway RPC)
  */
 export async function listOpenClawSessionsViaCli(
   options?: {
@@ -667,22 +690,69 @@ export async function listOpenClawSessionsViaCli(
   
   log?.info?.(`[session-history] Listing sessions via CLI`);
   
+  // Try local "openclaw sessions --json" first (no Gateway needed)
+  try {
+    const localArgs = ["--json"];
+    const result = await executeClawCommand(["sessions"], localArgs, { log });
+    
+    const parsed = JSON.parse(result) as {
+      sessions?: Array<{
+        key: string;
+        sessionId?: string;
+        sessionFile?: string;
+        updatedAt?: number;
+        label?: string;
+        displayName?: string;
+      }>;
+      count?: number;
+    };
+    
+    let sessions: OpenClawSession[] = (parsed.sessions ?? []).map((s) => ({
+      key: s.key,
+      sessionId: s.sessionId,
+      sessionFile: s.sessionFile,
+      updatedAt: s.updatedAt,
+      title: s.label || s.displayName,
+    }));
+    
+    // Apply limit
+    if (limit && sessions.length > limit) {
+      sessions = sessions.slice(0, limit);
+    }
+    
+    log?.info?.(`[session-history] Got ${sessions.length} sessions via CLI (local)`);
+    
+    return {
+      sessions,
+      total: parsed.count ?? sessions.length,
+    };
+  } catch (localErr) {
+    log?.debug?.(`[session-history] Local sessions command failed, trying gateway RPC: ${localErr}`);
+  }
+  
+  // Fall back to Gateway RPC: openclaw gateway call sessions.list --params '{...}' --json
   try {
-    const args = ["--json"];
+    const params: Record<string, unknown> = {};
     if (limit) {
-      args.push("--limit", String(limit));
+      params.limit = limit;
     }
     if (includeGlobal) {
-      args.push("--include-global");
+      params.includeGlobal = true;
     }
     if (includeUnknown) {
-      args.push("--include-unknown");
+      params.includeUnknown = true;
     }
     
-    const result = await executeClawCommand("rpc", ["sessions.list", ...args], {
-      log,
-      gatewayUrl: gatewayUrl || sessionFileConfig.gatewayUrl,
-    });
+    const args = ["--json", "--params", JSON.stringify(params)];
+    
+    const result = await executeClawCommand(
+      ["gateway", "call", "sessions.list"],
+      args,
+      {
+        log,
+        gatewayUrl: gatewayUrl || sessionFileConfig.gatewayUrl,
+      },
+    );
     
     const parsed = JSON.parse(result) as {
       sessions?: Array<{
@@ -704,7 +774,7 @@ export async function listOpenClawSessionsViaCli(
       title: s.label || s.displayName,
     }));
     
-    log?.info?.(`[session-history] Got ${sessions.length} sessions via CLI`);
+    log?.info?.(`[session-history] Got ${sessions.length} sessions via CLI (gateway RPC)`);
     
     return {
       sessions,