clawmoney 0.17.23 → 0.17.25

package/dist/hub/executor.d.ts

@@ -1,11 +1,19 @@
-import type { ProviderConfig, ServiceCallEvent, TestCallEvent, EscrowTaskEvent, DeliverEvent, TestResponseEvent } from "./types.js";
-type SendFn = (event: DeliverEvent | TestResponseEvent) => boolean;
+import type { ProviderConfig, ServiceCallEvent, TestCallEvent, EscrowTaskEvent, DeliverEvent, TestResponseEvent, ProgressEvent } from "./types.js";
+type SendFn = (event: DeliverEvent | TestResponseEvent | ProgressEvent) => boolean;
 export declare class Executor {
     private config;
     private send;
     private activeTasks;
     constructor(config: ProviderConfig, send: SendFn);
     get activeCount(): number;
+    /**
+     * Fire a progress update for an in-flight order. The buyer-facing UI
+     * (clawmoney-web playground) polls /market/orders/{id} and reads the
+     * `progress` field that backend Redis-caches from these events.
+     * Best-effort: failed sends are non-fatal (the UI just sees a slightly
+     * stale stage label until the next progress fires).
+     */
+    private sendProgress;
     handleServiceCall(call: ServiceCallEvent): void;
     handleEscrowTask(task: EscrowTaskEvent): void;
     private executeEscrowTask;

package/dist/hub/executor.js

@@ -201,7 +201,7 @@ async function waitForStableSize(filePath) {
     }
 }
 // ── CLI execution (openclaw agent / claude -p) ──
-function runCli(command, prompt, timeoutMs, orderId, watchForImage) {
+function runCli(command, prompt, timeoutMs, orderId, watchForImage, onProgress) {
     return new Promise((resolve) => {
         // Build args based on command
         let args;
@@ -290,6 +290,10 @@ function runCli(command, prompt, timeoutMs, orderId, watchForImage) {
             resolve({ stdout, stderr, exitCode: 0 });
         };
         if (dirBaseline) {
+            // Report once when codex actually starts working — the spawn ack
+            // is fast but the first reasoning step can take ~10s and we want
+            // the UI to know "we're actually running, not just queued".
+            onProgress?.("Generating image…");
             pollHandle = setInterval(() => {
                 if (earlyResolved)
                     return;
@@ -299,6 +303,7 @@ function runCli(command, prompt, timeoutMs, orderId, watchForImage) {
                         clearInterval(pollHandle);
                         pollHandle = null;
                     }
+                    onProgress?.("Image generated, finalizing…");
                     void finishWithEarlyImage(newImage);
                 }
             }, POLL_INTERVAL_MS);
@@ -456,6 +461,22 @@ export class Executor {
     get activeCount() {
         return this.activeTasks.size;
     }
+    /**
+     * Fire a progress update for an in-flight order. The buyer-facing UI
+     * (clawmoney-web playground) polls /market/orders/{id} and reads the
+     * `progress` field that backend Redis-caches from these events.
+     * Best-effort: failed sends are non-fatal (the UI just sees a slightly
+     * stale stage label until the next progress fires).
+     */
+    sendProgress(orderId, text) {
+        try {
+            this.send({ event: "progress", order_id: orderId, progress: text });
+        }
+        catch {
+            // Ignore — WS may be reconnecting; the next progress event will
+            // pick up where we left off.
+        }
+    }
     handleServiceCall(call) {
         if (isProcessed(call.order_id)) {
             logger.info(`Skipping duplicate order: ${call.order_id}`);
@@ -650,11 +671,15 @@ export class Executor {
             const timeoutS = Math.max(call.timeout - TIMEOUT_BUFFER_S, 30);
             const command = this.config.provider.cli_command;
             logger.info(`Executing: ${command} for skill="${call.skill}" order=${call.order_id} (timeout=${timeoutS}s)`);
+            this.sendProgress(call.order_id, `Spawning ${command}…`);
             const { stdout, stderr, exitCode } = await runCli(command, prompt, timeoutS * 1000, call.order_id, 
             // Watch the codex image dir for generation/image so we can
             // ship the moment the file lands, skipping codex's final
             // reasoning tail (~60–90s of pure overhead).
-            call.category?.startsWith("generation/image"));
+            call.category?.startsWith("generation/image"), 
+            // Progress callback fired inside runCli when we cross
+            // observable milestones (image landing on disk, etc).
+            (text) => this.sendProgress(call.order_id, text));
             if (exitCode !== 0) {
                 const errMsg = stderr.trim() || `CLI exited with code ${exitCode}`;
                 logger.error(`CLI failed (code=${exitCode}):`, errMsg);
@@ -701,6 +726,9 @@ export class Executor {
                     }
                 }
                 // Upload local files to R2
+                if (allFiles.length > 0) {
+                    this.sendProgress(call.order_id, "Uploading to CDN…");
+                }
                 for (const filePath of allFiles) {
                     const cdnUrl = await uploadFile(filePath, this.config);
                     if (cdnUrl) {

package/dist/hub/types.d.ts

@@ -56,7 +56,20 @@ export interface TestResponseEvent {
     order_id: string;
     output: Record<string, unknown>;
 }
-export type OutgoingEvent = DeliverEvent | TestResponseEvent;
+/**
+ * Live in-flight progress reported back to backend during a service_call.
+ * Backend stashes the text at hub:progress:<order_id> in Redis with a
+ * 10-minute TTL; clawmoney-web's playground poll picks it up via the
+ * HubOrderPublic.progress field. Fire-and-forget — backend doesn't
+ * ack, so dropped progress messages just mean the UI sees a slightly
+ * stale stage label.
+ */
+export interface ProgressEvent {
+    event: "progress";
+    order_id: string;
+    progress: string;
+}
+export type OutgoingEvent = DeliverEvent | TestResponseEvent | ProgressEvent;
 export interface ProviderSettings {
     cli_command: string;
     max_concurrent: number;

package/dist/hub/ws-client.js

@@ -102,7 +102,21 @@ export class WsClient {
         this.stopHeartbeat();
         this.heartbeatTimer = setInterval(() => {
             if (this.ws && this.ws.readyState === WebSocket.OPEN) {
-                this.ws.ping();
+                // Application-level heartbeat. Backend's `event == "heartbeat"`
+                // handler is what updates ClawAgent.last_heartbeat_at, which in
+                // turn drives the `agent_is_online` field on /market/skills/search
+                // results. A WS protocol-level ping/pong (this.ws.ping()) keeps
+                // the TCP connection alive but the backend never sees it as a
+                // JSON message — so DB heartbeat would only ever get bumped at
+                // initial connect, then go stale after 600s and the agent would
+                // disappear from search results despite the daemon being fine.
+                try {
+                    this.ws.send(JSON.stringify({ event: "heartbeat" }));
+                }
+                catch {
+                    // Send failure is non-fatal; the reconnect loop will pick up
+                    // a real socket close if the connection is actually dead.
+                }
             }
         }, HEARTBEAT_INTERVAL_MS);
         this.heartbeatTimer.unref();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clawmoney",
-  "version": "0.17.23",
+  "version": "0.17.25",
   "description": "ClawMoney CLI -- Earn rewards with your AI agent",
   "type": "module",
   "bin": {