@claw-link/gateway-host 0.3.4 → 0.3.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@claw-link/gateway-host",
-  "version": "0.3.4",
+  "version": "0.3.5",
   "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

@@ -45,7 +45,7 @@ function buildArgv(template, vars) {
  * This returns an async iterator of events. The prompt is passed via stdin when
  * `stdin` is true (preferred — keeps it out of argv/process listings entirely).
  */
-async function* spawnStreaming({ binary, argv, cwd, env, timeoutMs = 600000, stdinInput = null, parseLine }) {
+async function* spawnStreaming({ binary, argv, cwd, env, timeoutMs = 600000, stdinInput = null, parseLine, signal = null }) {
   if (!binary) throw new Error('no runtime binary configured');
 
   // Windows: npm CLIs are `.cmd`/`.bat` shims, and modern Node REFUSES to spawn those
@@ -73,6 +73,17 @@ async function* spawnStreaming({ binary, argv, cwd, env, timeoutMs = 600000, std
     ? setTimeout(() => { killed = true; try { child.kill('SIGKILL'); } catch { /* gone */ } }, timeoutMs)
     : null;
 
+  // Abort (the run was cancelled): stop the agent promptly — SIGTERM, then SIGKILL if it lingers.
+  const onAbort = () => {
+    killed = true;
+    try { child.kill('SIGTERM'); } catch { /* gone */ }
+    setTimeout(() => { try { child.kill('SIGKILL'); } catch { /* gone */ } }, 3000).unref();
+  };
+  if (signal) {
+    if (signal.aborted) onAbort();
+    else signal.addEventListener('abort', onAbort, { once: true });
+  }
+
   if (stdinInput != null) {
     try { child.stdin.write(stdinInput); } catch { /* ignore */ }
   }

package/src/adapters/cli.js

@@ -90,7 +90,7 @@ function makeCliAdapter(cfg) {
     name: cfg.name,
     binaries: cfg.binaries,
 
-    async *run({ agent, job, logger }) {
+    async *run({ agent, job, logger, signal }) {
       const binary = agent.binary || cfg.binaries[0];
       const userPrompt = job.content || '';
       const systemPrompt = job.system_prompt || '';
@@ -135,7 +135,7 @@ function makeCliAdapter(cfg) {
           : genericLineParser;
         for await (const evt of spawnStreaming({
           binary, argv: argvFor(rid), cwd: agent.work_dir, timeoutMs,
-          stdinInput: cfg.promptViaStdin ? fullPrompt : null, parseLine,
+          stdinInput: cfg.promptViaStdin ? fullPrompt : null, parseLine, signal,
         })) {
           if (evt.type === 'chunk') emittedAny = true;
           yield evt;

package/src/bridge.js

@@ -41,6 +41,8 @@ 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) }); }
+  // 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.
   capsulePut(path) { return this._post('capsule_put', { path }); }
   capsuleGet(path) { return this._post('capsule_get', { path }); }

package/src/worker.js

@@ -56,11 +56,24 @@ async function processJob(bridge, agentCfg, job, p2p) {
   // H2H: pull in any large upstream bytes (P2P, DB floor) before the runtime sees the prompt.
   await resolveTransport(bridge, p2p, job);
   const adapter = getAdapter(agentCfg.runtime);
+  // Cancellation: poll the job's status while it runs; if the run was cancelled (or the job errored/
+  // expired server-side), abort the child so the agent STOPS promptly instead of grinding on.
+  const ac = new AbortController();
+  const cancelPoll = setInterval(() => {
+    bridge.jobStatus(job.id)
+      .then((r) => {
+        if (r && ['cancelled', 'error', 'expired'].includes(String(r.status)) && !ac.signal.aborted) {
+          logger.info(`job ${job.id} ${r.status} — stopping the agent`);
+          ac.abort();
+        }
+      })
+      .catch(() => { /* transient — keep polling */ });
+  }, 4000);
   let seq = 0;
   let finalText = '';
   let toolCalls = [];
   try {
-    for await (const evt of adapter.run({ agent: agentCfg, job, logger })) {
+    for await (const evt of adapter.run({ agent: agentCfg, job, logger, signal: ac.signal })) {
       if (!evt || !evt.type) continue;
       // Structured tool calls aren't streamed as a chunk — collected for the final
       // metadata so the server can extract rich UI (clawlink_ui).
@@ -69,6 +82,7 @@ async function processJob(bridge, agentCfg, job, p2p) {
       try { await bridge.stream(job.id, seq++, evt.type, String(evt.content ?? '')); }
       catch (e) { logger.warn(`stream seq ${seq} failed: ${e.message}`); }
     }
+    if (ac.signal.aborted) { logger.info(`job ${job.id} cancelled — not completing`); 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.
@@ -88,8 +102,11 @@ async function processJob(bridge, agentCfg, job, p2p) {
     if (offerCid) await p2p.announce(bridge, offerCid);
     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; }
     logger.error(`job ${job.id} failed: ${e.message}`);
     try { await bridge.fail(job.id, e.message); } catch { /* ignore */ }
+  } finally {
+    clearInterval(cancelPoll);
   }
 }