@claw-link/gateway-host 0.3.18 → 0.4.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@claw-link/gateway-host",
-  "version": "0.3.18",
+  "version": "0.4.1",
   "description": "ClawLink Host Gateway — a secure, outbound-only worker that bridges a local agent CLI (OpenClaw, Hermes, Claude, Codex, Cursor) to your ClawLink agents. No inbound ports; authenticated per-agent by a Host Token.",
   "homepage": "https://claw-link.co",
   "bin": {

package/src/adapters/base.js

@@ -15,6 +15,71 @@ const { spawn } = require('child_process');
 const logger = require('../logger');
 const { enrichedEnv } = require('../paths');
 
+// ── Claude session/usage-limit detection ─────────────────────────────────────
+// When the CLI hits its subscription window it prints something like
+// "You've hit your session limit · resets 1:20pm (Asia/Singapore)" (as output OR
+// stderr) and exits non-zero — or exits 0 with the notice AS the whole answer.
+// The worker turns a detection into a bridge `pause` so the run waits for the
+// reset instead of failing.
+//
+// Precision matters: a false positive parks a legitimate reply for up to an hour.
+// So we require the NOTICE PHRASING ("hit/reached your … limit", "limit reached",
+// "…limit · resets"), not merely the topical words "rate limit" — an agent that
+// mentions rate limits in its answer must not be mistaken for a hit.
+const LIMIT_NOTICE_RE = /\b(?:hit|reached|exceeded)\s+(?:your\s+)?(?:\w+\s+){0,2}(?:session|usage|rate|message|token)\s+limit\b|\b(?:session|usage|rate|message|token)\s+limit\s+(?:reached|exceeded|hit)\b|\blimit\s*[·|]\s*resets?\b/i;
+const RESET_RE = /\bresets?\b/i;
+
+/** Parse "resets 1:20pm (Asia/Singapore)" → ISO timestamp of the NEXT such wall-clock
+ *  time in that timezone (+2 min safety margin). Null when unparseable. */
+function parseResetAt(text) {
+  const m = String(text || '').match(/resets?\s+(?:at\s+)?(\d{1,2})(?::(\d{2}))?\s*(am|pm)?(?:\s*\(([^)]+)\))?/i);
+  if (!m) return null;
+  let hour = parseInt(m[1], 10);
+  const minute = m[2] ? parseInt(m[2], 10) : 0;
+  const ampm = (m[3] || '').toLowerCase();
+  if (ampm === 'pm' && hour < 12) hour += 12;
+  if (ampm === 'am' && hour === 12) hour = 0;
+  if (!Number.isFinite(hour) || hour > 23 || minute > 59) return null;
+  const tz = (m[4] || '').trim();
+  try {
+    // Current wall-clock time in the target tz → minutes until the reset time.
+    const now = new Date();
+    const fmt = new Intl.DateTimeFormat('en-GB', {
+      ...(tz ? { timeZone: tz } : {}), hour: '2-digit', minute: '2-digit', hour12: false,
+    });
+    const parts = fmt.formatToParts(now);
+    const curH = parseInt(parts.find((p) => p.type === 'hour')?.value ?? '0', 10);
+    const curM = parseInt(parts.find((p) => p.type === 'minute')?.value ?? '0', 10);
+    let delta = (hour * 60 + minute) - (curH * 60 + curM);
+    if (delta <= 0) delta += 24 * 60;          // already past today → tomorrow
+    return new Date(now.getTime() + (delta + 2) * 60 * 1000).toISOString();
+  } catch {
+    return null; // unknown/invalid IANA tz string
+  }
+}
+
+/** Detect a limit NOTICE (not merely the topic) in output/stderr on a failed run;
+ *  returns {resumeAt, message} or null. `redact` (from logger) scrubs secrets before
+ *  the message is shipped to the server / shown in the Studio. */
+function detectRateLimit(text, redact) {
+  const t = String(text || '');
+  if (!LIMIT_NOTICE_RE.test(t)) return null;
+  const tail = t.slice(-300).trim();
+  return {
+    resumeAt: parseResetAt(t) || new Date(Date.now() + 60 * 60 * 1000).toISOString(),
+    message: (typeof redact === 'function' ? redact(tail) : tail),
+  };
+}
+
+/** True when the whole final reply IS the limit notice (exit-0 case): short AND
+ *  matches the notice phrasing AND names a reset — must never be stored as a result.
+ *  Requiring the notice phrasing (not just "rate limit") keeps a short benign reply
+ *  that merely discusses limits from being swallowed. */
+function isLimitMessage(text) {
+  const t = String(text || '').trim();
+  return t.length > 0 && t.length <= 300 && LIMIT_NOTICE_RE.test(t) && RESET_RE.test(t);
+}
+
 // A small set of flags we refuse to pass through (auto-approve / no-safety modes).
 const FORBIDDEN_FLAGS = [
   '--yolo', '--dangerously-skip-permissions', '--no-sandbox', '--allow-all',
@@ -101,8 +166,14 @@ async function* spawnStreaming({ binary, argv, cwd, env, timeoutMs = 600000, std
   };
 
   let stdoutBuf = '';
+  // Bounded tail of everything the runtime printed (stdout + stderr), used on failure
+  // to recognize a session-limit notice and type the error as rate_limited.
+  let tailBuf = '';
+  const addTail = (s) => { tailBuf = (tailBuf + s).slice(-4096); };
   const handleChunk = (buf) => {
-    stdoutBuf += buf.toString();
+    const s = buf.toString();
+    addTail(s);
+    stdoutBuf += s;
     let idx;
     while ((idx = stdoutBuf.indexOf('\n')) >= 0) {
       const line = stdoutBuf.slice(0, idx);
@@ -113,7 +184,9 @@ async function* spawnStreaming({ binary, argv, cwd, env, timeoutMs = 600000, std
 
   child.stdout.on('data', handleChunk);
   child.stderr.on('data', (b) => {
-    const text = logger.redact(b.toString()).trim();
+    const raw = b.toString();
+    addTail(raw);
+    const text = logger.redact(raw).trim();
     if (text) push({ type: 'log', content: text.slice(0, 500) });
   });
 
@@ -121,7 +194,16 @@ async function* spawnStreaming({ binary, argv, cwd, env, timeoutMs = 600000, std
     clearTimeout(timer);
     if (stdoutBuf.trim()) for (const evt of (parseLine(stdoutBuf) || [])) push(evt);
     if (killed) exitErr = new Error(`runtime timed out after ${timeoutMs}ms`);
-    else if (code !== 0) exitErr = new Error(`runtime exited with code ${code}`);
+    else if (code !== 0) {
+      const limit = detectRateLimit(tailBuf, logger.redact);
+      if (limit) {
+        exitErr = Object.assign(new Error(limit.message || `runtime exited with code ${code}`), {
+          code: 'rate_limited', resumeAt: limit.resumeAt,
+        });
+      } else {
+        exitErr = new Error(`runtime exited with code ${code}`);
+      }
+    }
     done = true;
     if (resolveNext) { resolveNext(); resolveNext = null; }
   });
@@ -140,4 +222,4 @@ async function* spawnStreaming({ binary, argv, cwd, env, timeoutMs = 600000, std
   if (exitErr) throw exitErr;
 }
 
-module.exports = { spawnStreaming, buildArgv, FORBIDDEN_FLAGS };
+module.exports = { spawnStreaming, buildArgv, FORBIDDEN_FLAGS, detectRateLimit, isLimitMessage };

package/src/bridge.js

@@ -60,6 +60,9 @@ class Bridge {
   stream(jobId, seq, type, content) { return this._post('stream', { job_id: jobId, seq, type, content }); }
   complete(jobId, finalContent, metadata) { return this._post('complete', { job_id: jobId, final_content: finalContent, metadata: metadata || {} }); }
   fail(jobId, error) { return this._post('fail', { job_id: jobId, error: String(error).slice(0, 1000) }); }
+  // Session-limit hit: park the job server-side until resume_at (run stays alive); the same
+  // machine re-claims it after the reset and --resume continues the conversation.
+  pause(jobId, resumeAt, message) { return this._post('pause', { job_id: jobId, resume_at: resumeAt, message: String(message ?? '').slice(0, 500) }); }
   // Poll a running job's status so the worker can abort the agent if the run was cancelled.
   jobStatus(jobId) { return this._post('job_status', { job_id: jobId }); }
   // AHP data plane: request short-lived signed URLs to sync content-addressed Capsule bytes.

package/src/worker.js

@@ -10,6 +10,7 @@ const logger = require('./logger');
 const config = require('./config');
 const { Bridge, withRetry } = require('./bridge');
 const { getAdapter } = require('./adapters');
+const { detectRateLimit, isLimitMessage } = require('./adapters/base');
 const { detectRuntimes } = require('./detect');
 const { P2P } = require('./transport/p2p');
 const control = require('./control');
@@ -100,6 +101,21 @@ async function processJob(bridge, agentCfg, job, p2p) {
       catch (e) { logger.warn(`stream seq ${seq} failed: ${e.message}`); }
     }
     if (ac.signal.aborted) { logger.info(`job ${job.id} cancelled — not completing`); return; }
+    // Session-limit notice delivered as a NORMAL reply (exit 0): the whole answer is the
+    // limit message. Never store that as the node's result — pause the job instead so the
+    // run resumes after the reset (server parks it with not_before; --resume continues).
+    if (job.harness && isLimitMessage(finalText)) {
+      const limit = detectRateLimit(finalText, logger.redact) || { resumeAt: new Date(Date.now() + 60 * 60 * 1000).toISOString(), message: logger.redact(finalText) };
+      logger.warn(`job ${job.id} rate-limited — pausing until ${limit.resumeAt}`);
+      try {
+        await withRetry(() => bridge.pause(job.id, limit.resumeAt, limit.message));
+        return;
+      } catch (pe) {
+        logger.warn(`pause not supported by server (${pe.message}) — failing instead`);
+        try { await bridge.fail(job.id, limit.message); } catch { /* ignore */ }
+        return;
+      }
+    }
     // H2H: store a large result for P2P fetch by the next node's host (inline copy stays the floor).
     // We add+ref it before complete(), but ANNOUNCE only AFTER complete() persists the capsule — so
     // the directory can verify this host is the producer before listing it.
@@ -120,6 +136,17 @@ async function processJob(bridge, agentCfg, job, p2p) {
     logger.info(`job ${job.id} done (${finalText.length} chars${transport ? `, P2P-offered ${transport.cid.slice(0, 14)}…` : ''})`);
   } catch (e) {
     if (ac.signal.aborted) { logger.info(`job ${job.id} cancelled — agent stopped`); return; }
+    // Typed rate-limit (nonzero exit + limit notice in the output tail): pause, don't fail.
+    // An old server without the pause action degrades to today's fail behavior.
+    if (e && e.code === 'rate_limited' && job.harness) {
+      logger.warn(`job ${job.id} rate-limited — pausing until ${e.resumeAt}`);
+      try {
+        await withRetry(() => bridge.pause(job.id, e.resumeAt, e.message));
+        return;
+      } catch (pe) {
+        logger.warn(`pause not supported by server (${pe.message}) — failing instead`);
+      }
+    }
     logger.error(`job ${job.id} failed: ${e.message}`);
     try { await bridge.fail(job.id, e.message); } catch { /* ignore */ }
   } finally {