@linkedclaw/openclaw-plugin 0.1.10 → 0.1.11

package/dist/index.d.ts

@@ -136,6 +136,14 @@ interface PluginRuntimeConfig extends ProviderConfig {
     autoAcceptInvokes: boolean;
     autoAcceptSessions: boolean;
     autoAcceptGigTasks: boolean;
+    /**
+     * Which OpenClaw agent serves marketplace jobs — the `<agent>` segment of the
+     * subagent session key (`agent:<id>:subagent:...`). Default `"main"`. Point
+     * this at a dedicated Docker-sandboxed agent (sandbox mode=all, scope=agent,
+     * restricted tools) so untrusted requester prompts run inside a real boundary,
+     * not the operator's main agent. See the provider skill's security step.
+     */
+    servingAgentId: string;
 }
 declare function parseConfig(raw: Record<string, unknown>): PluginRuntimeConfig;
 

package/dist/index.js

@@ -11964,6 +11964,19 @@ var DEFAULT_AUTH_FAILURE_CODES = Object.freeze([
   1008,
   ...Array.from({ length: 99 }, (_, i) => 4001 + i)
 ]);
+var DEFAULT_AUTH_FATAL_FRAME_CODES = Object.freeze([
+  "identify_invalid",
+  "secret_isolation_violation",
+  "key_revoked",
+  "key_scope_insufficient",
+  "token_invalid",
+  "agent_unauthorized",
+  "actor_unauthorized",
+  "agent_not_found",
+  "mandate_not_found",
+  "mandate_inactive",
+  "mandate_binding_failed"
+]);
 var RelayClient = class extends EventEmitter {
   url;
   agentId;
@@ -11973,14 +11986,19 @@ var RelayClient = class extends EventEmitter {
   reconnectBaseMs;
   reconnectMaxMs;
   authGraceMs;
+  handshakeTimeoutMs;
   authFailureCloseCodes;
+  authFatalFrameCodes;
   connector;
   transport;
   heartbeatTimer;
   authGraceTimer;
   stopped = false;
   reconnectAttempt = 0;
+  throttled = false;
   fatalState = null;
+  fireEnd;
+  loopPromise;
   constructor(opts) {
     super();
     this.url = opts.url;
@@ -11991,9 +12009,9 @@ var RelayClient = class extends EventEmitter {
     this.reconnectBaseMs = opts.reconnectBaseMs ?? 1e3;
     this.reconnectMaxMs = opts.reconnectMaxMs ?? 3e4;
     this.authGraceMs = opts.authGraceMs ?? 5e3;
-    this.authFailureCloseCodes = new Set(
-      opts.authFailureCloseCodes ?? DEFAULT_AUTH_FAILURE_CODES
-    );
+    this.handshakeTimeoutMs = opts.handshakeTimeoutMs ?? 1e4;
+    this.authFailureCloseCodes = new Set(opts.authFailureCloseCodes ?? DEFAULT_AUTH_FAILURE_CODES);
+    this.authFatalFrameCodes = new Set(opts.authFatalFrameCodes ?? DEFAULT_AUTH_FATAL_FRAME_CODES);
     this.connector = opts.connector ?? nodeWsConnector;
   }
   getFatal() {
@@ -12005,27 +12023,17 @@ var RelayClient = class extends EventEmitter {
   emit(event, ...args) {
     return super.emit(event, ...args);
   }
+  /**
+   * Open the first connection. Resolves once identify is sent; rejects on
+   * first-attempt failure ("initial failure = caller's problem" — e.g. the
+   * plugin holders surface it to the operator). Either way, NO background
+   * reconnect chains survive a failed connect().
+   */
   async connect() {
     this.stopped = false;
-    await this.openOnce();
-  }
-  async openOnce() {
-    try {
-      const { transport, ready } = await this.connector(this.url);
-      this.transport = transport;
-      transport.addMessageListener((data) => this.handleFrame(data));
-      transport.addCloseListener(
-        (code, reason) => this.handleClose(code, `close ${code}: ${reason}`)
-      );
-      transport.addErrorListener((err) => this.handleClose(null, `error: ${err.message}`));
-      await ready;
-      await this.sendIdentify();
-      this.startHeartbeat();
-      this.emit("connected");
-      this.startAuthGraceTimer();
-    } catch (err) {
-      throw new NetworkError(`relay connect failed: ${err.message}`, err);
-    }
+    this.fatalState = null;
+    const first = await this.openConnection();
+    this.loopPromise = this.runLoop(first.ended);
   }
   async send(frame) {
     if (!this.transport) throw new NetworkError("relay not connected");
@@ -12042,7 +12050,132 @@ var RelayClient = class extends EventEmitter {
       }
       this.transport = void 0;
     }
+    this.fireEnd?.({ code: 1e3, reason: "client_stop" });
+    await this.loopPromise?.catch(() => {
+    });
+    this.loopPromise = void 0;
+  }
+  // ------------------------------------------------------------------
+  // Connection lifecycle (single-flight)
+  // ------------------------------------------------------------------
+  async openConnection() {
+    let resolveEnd;
+    const ended = new Promise((r) => {
+      resolveEnd = r;
+    });
+    let fired = false;
+    const fireEnd = (e) => {
+      if (!fired) {
+        fired = true;
+        resolveEnd(e);
+      }
+    };
+    this.fireEnd = fireEnd;
+    try {
+      const { transport, ready } = await this.connector(this.url, {
+        handshakeTimeoutMs: this.handshakeTimeoutMs
+      });
+      transport.addMessageListener((data) => this.handleFrame(data));
+      transport.addCloseListener((code, reason) => fireEnd({ code, reason: `close ${code}: ${reason}` }));
+      transport.addErrorListener(
+        (err) => fireEnd({
+          code: null,
+          reason: `error: ${err.message}`,
+          httpStatus: err.httpStatus
+        })
+      );
+      await this.withHandshakeTimeout(ready);
+      this.transport = transport;
+      await this.sendIdentify();
+      this.startHeartbeat();
+      this.emit("connected");
+      this.startAuthGraceTimer();
+      return { ended };
+    } catch (err) {
+      fireEnd({
+        code: null,
+        reason: `connect failed: ${err.message}`,
+        httpStatus: err.httpStatus
+      });
+      throw new NetworkError(`relay connect failed: ${err.message}`, err);
+    }
+  }
+  async withHandshakeTimeout(ready) {
+    let timer;
+    const timeout = new Promise((_, reject) => {
+      timer = setTimeout(
+        () => reject(new Error(`handshake timeout after ${this.handshakeTimeoutMs}ms`)),
+        this.handshakeTimeoutMs
+      );
+      timer.unref?.();
+    });
+    try {
+      await Promise.race([ready, timeout]);
+    } finally {
+      if (timer) clearTimeout(timer);
+    }
   }
+  async runLoop(firstEnded) {
+    let ended = firstEnded;
+    while (true) {
+      const end = await ended;
+      this.stopHeartbeat();
+      this.cancelAuthGraceTimer();
+      this.transport = void 0;
+      this.emit("disconnected", end.reason);
+      if (this.stopped) return;
+      const fatal = this.classifyFatal(end);
+      if (fatal) {
+        this.stopped = true;
+        this.fatalState = fatal;
+        this.emit("fatal", fatal);
+        return;
+      }
+      this.throttled = end.code === 1013;
+      for (; ; ) {
+        await this.backoffDelay();
+        if (this.stopped) return;
+        try {
+          ({ ended } = await this.openConnection());
+          break;
+        } catch (err) {
+          const status = err.httpStatus ?? err.cause?.httpStatus;
+          if (status === 401 || status === 403) {
+            const info = { reason: `upgrade rejected: HTTP ${status}`, code: null };
+            this.stopped = true;
+            this.fatalState = info;
+            this.emit("fatal", info);
+            return;
+          }
+        }
+      }
+    }
+  }
+  classifyFatal(end) {
+    if (end.fatalFrameCode) {
+      return { reason: `fatal error frame: ${end.fatalFrameCode}`, code: end.code };
+    }
+    if (end.code !== null && this.authFailureCloseCodes.has(end.code)) {
+      return { reason: end.reason, code: end.code };
+    }
+    if (end.httpStatus === 401 || end.httpStatus === 403) {
+      return { reason: `upgrade rejected: HTTP ${end.httpStatus}`, code: null };
+    }
+    return null;
+  }
+  async backoffDelay() {
+    this.reconnectAttempt += 1;
+    let base = Math.min(this.reconnectBaseMs * 2 ** (this.reconnectAttempt - 1), this.reconnectMaxMs);
+    if (this.throttled) base = Math.min(base * 2, this.reconnectMaxMs * 2);
+    const jitter = base * (0.5 + Math.random());
+    await new Promise((r) => {
+      const t = setTimeout(r, jitter);
+      t.unref?.();
+    });
+  }
+  // ------------------------------------------------------------------
+  // Frames / heartbeat / grace (unchanged semantics)
+  // ------------------------------------------------------------------
   async sendIdentify() {
     await this.send({
       type: MessageType.IDENTIFY,
@@ -12077,33 +12210,30 @@ var RelayClient = class extends EventEmitter {
     } catch {
       return;
     }
+    if (frame.type === "error" && typeof frame.code === "string" && this.authFatalFrameCodes.has(frame.code)) {
+      this.fireEnd?.({
+        code: null,
+        reason: `error frame: ${frame.code}`,
+        fatalFrameCode: frame.code
+      });
+    }
     this.emit("raw", frame);
     const evt = parseInbound(frame);
     if (evt) this.emit("event", evt);
   }
-  handleClose(code, reason) {
-    this.stopHeartbeat();
-    this.cancelAuthGraceTimer();
-    this.transport = void 0;
-    this.emit("disconnected", reason);
-    if (this.stopped) return;
-    if (code !== null && this.authFailureCloseCodes.has(code)) {
-      this.stopped = true;
-      this.fatalState = { reason, code };
-      this.emit("fatal", { reason, code });
-      return;
-    }
-    void this.scheduleReconnect();
-  }
   startAuthGraceTimer() {
     this.cancelAuthGraceTimer();
     if (this.authGraceMs <= 0) {
       this.reconnectAttempt = 0;
+      this.throttled = false;
       return;
     }
     this.authGraceTimer = setTimeout(() => {
       this.authGraceTimer = void 0;
-      if (this.transport) this.reconnectAttempt = 0;
+      if (this.transport) {
+        this.reconnectAttempt = 0;
+        this.throttled = false;
+      }
     }, this.authGraceMs);
     if (typeof this.authGraceTimer.unref === "function") {
       this.authGraceTimer.unref();
@@ -12115,30 +12245,15 @@ var RelayClient = class extends EventEmitter {
       this.authGraceTimer = void 0;
     }
   }
-  async scheduleReconnect() {
-    this.reconnectAttempt += 1;
-    const base = Math.min(
-      this.reconnectBaseMs * 2 ** (this.reconnectAttempt - 1),
-      this.reconnectMaxMs
-    );
-    const jitter = base * (0.5 + Math.random());
-    await new Promise((r) => {
-      const t = setTimeout(r, jitter);
-      if (typeof t.unref === "function") {
-        t.unref();
-      }
-    });
-    if (this.stopped) return;
-    try {
-      await this.openOnce();
-    } catch {
-      if (!this.stopped) void this.scheduleReconnect();
-    }
-  }
 };
-var nodeWsConnector = async (url) => {
+var nodeWsConnector = async (url, opts) => {
   const { WebSocket: WebSocket2 } = await Promise.resolve().then(() => (init_wrapper(), wrapper_exports));
-  const ws = new WebSocket2(url);
+  const ws = new WebSocket2(url, { handshakeTimeout: opts?.handshakeTimeoutMs ?? 1e4 });
+  ws.on("unexpected-response", (_req, res) => {
+    const err = new Error(`unexpected server response: ${res.statusCode}`);
+    err.httpStatus = res.statusCode;
+    ws.emit("error", err);
+  });
   const transport = {
     send: (data) => {
       return new Promise((resolve, reject) => {
@@ -12318,6 +12433,8 @@ var DEFAULT_INVOKE_TIMEOUT_MS = 3e4;
 var DEFAULT_SESSION_TURN_TIMEOUT_MS = 6e4;
 var DEFAULT_GIG_TASK_OFFER_TIMEOUT_MS = 3e4;
 var DEFAULT_GIG_TASK_EXECUTE_TIMEOUT_MS = 3e5;
+var DEFAULT_SESSION_IDLE_TIMEOUT_MS = 144e5;
+var DEFAULT_SESSION_REAPER_INTERVAL_MS = 3e5;
 var GIG_TASK_SUBMIT_MAX_RETRIES = 3;
 var GIG_TASK_SUBMIT_BASE_MS = 500;
 var GIG_TASK_SUBMIT_CAP_MS = 8e3;
@@ -12335,6 +12452,7 @@ var ProviderRuntime = class {
   running = false;
   connected = false;
   fatal = null;
+  reaperTimer = null;
   constructor(deps) {
     this.cloud = deps.cloud;
     this.relay = deps.relay;
@@ -12545,10 +12663,45 @@ var ProviderRuntime = class {
     this.relay.on("event", (evt) => {
       void this.dispatch(evt);
     });
+    const interval = this.config.sessionReaperIntervalMs ?? DEFAULT_SESSION_REAPER_INTERVAL_MS;
+    this.reaperTimer = setInterval(() => {
+      void this.reapIdleSessions();
+    }, interval);
+    this.reaperTimer.unref?.();
     await this.relay.connect();
   }
+  /**
+   * Evict sessions idle past the TTL (#28a). For each, run onSessionEnd(..., "idle_timeout")
+   * so provider-side cleanup fires, emit `session_reaped` for observability, and free the
+   * slot so a subsequent create succeeds where it would otherwise hit `provider_busy`.
+   * Mirrors py `ProviderSkill._reaper_loop`.
+   */
+  async reapIdleSessions() {
+    const ttl = this.config.sessionIdleTimeoutMs ?? DEFAULT_SESSION_IDLE_TIMEOUT_MS;
+    const now = performance.now();
+    for (const sessionId of [...this.activeSessions.keys()]) {
+      const session = this.activeSessions.get(sessionId);
+      if (!session || now - session.lastActivity < ttl) continue;
+      this.activeSessions.delete(sessionId);
+      this.emitEvent("session_reaped", { session_id: sessionId });
+      if (this.handler.onSessionEnd) {
+        try {
+          await this.handler.onSessionEnd({
+            type: "session.end",
+            session_id: sessionId,
+            reason: "idle_timeout"
+          });
+        } catch {
+        }
+      }
+    }
+  }
   async stop() {
     this.running = false;
+    if (this.reaperTimer !== null) {
+      clearInterval(this.reaperTimer);
+      this.reaperTimer = null;
+    }
     if (this.activeSessions.size > 0) {
       this.emitEvent("draining", { live_sessions: this.activeSessions.size });
     }
@@ -12656,7 +12809,9 @@ var ProviderRuntime = class {
     const activeSession = {
       requesterId: evt.requester_id,
       capability: evt.capability,
-      replySeq: 0
+      replySeq: 0,
+      lastActivity: performance.now()
+      // monotonic — reaper parity (#28a)
     };
     const acceptExtras = {};
     const reqEphB64 = evt.eph_enc_pub;
@@ -12677,6 +12832,7 @@ var ProviderRuntime = class {
   async handleSessionMessage(evt) {
     const session = this.activeSessions.get(evt.session_id);
     if (!session) return;
+    session.lastActivity = performance.now();
     const timeout = this.config.sessionTurnTimeoutMs ?? DEFAULT_SESSION_TURN_TIMEOUT_MS;
     let handlerEvt = evt;
     if (session.K) {
@@ -12763,7 +12919,7 @@ var ProviderRuntime = class {
     }
   }
   async handleSessionEnd(evt) {
-    this.activeSessions.delete(evt.session_id);
+    if (!this.activeSessions.delete(evt.session_id)) return;
     if (this.handler.onSessionEnd) {
       try {
         await this.handler.onSessionEnd(evt);
@@ -13075,7 +13231,8 @@ function parseConfig(raw) {
     autoStartProvider: raw["autoStartProvider"] !== false,
     autoAcceptInvokes: raw["autoAcceptInvokes"] !== false,
     autoAcceptSessions: raw["autoAcceptSessions"] !== false,
-    autoAcceptGigTasks: raw["autoAcceptGigTasks"] === true
+    autoAcceptGigTasks: raw["autoAcceptGigTasks"] === true,
+    servingAgentId: typeof raw["servingAgentId"] === "string" && raw["servingAgentId"].trim() ? raw["servingAgentId"].trim() : "main"
   };
 }
 
@@ -13206,13 +13363,13 @@ var SubagentHandler = class {
   }
   // ───── keys ─────
   sessionKey(id) {
-    return `agent:main:subagent:linkedclaw-session-${id}`;
+    return `agent:${this.config.servingAgentId}:subagent:linkedclaw-session-${id}`;
   }
   invokeKey(id) {
-    return `agent:main:subagent:linkedclaw-invoke-${id}`;
+    return `agent:${this.config.servingAgentId}:subagent:linkedclaw-invoke-${id}`;
   }
   gigTaskKey(id) {
-    return `agent:main:subagent:linkedclaw-gig-task-${id}`;
+    return `agent:${this.config.servingAgentId}:subagent:linkedclaw-gig-task-${id}`;
   }
 };
 function formatPayload(payload) {