agentlife 1.4.1 → 1.5.1

package/dist/index.js

@@ -2070,6 +2070,24 @@ function visionSurfaceCount(state) {
       n++;
   return n;
 }
+function specialistHasAnySurface(state, specialistId) {
+  if (!state.surfaceDb)
+    return false;
+  for (const id of state.surfaceDb.keys()) {
+    if (state.surfaceDb.getAgentId(id) === specialistId)
+      return true;
+  }
+  return false;
+}
+function specialistIdFromSessionKey(sessionKey) {
+  if (!sessionKey)
+    return null;
+  const parts = sessionKey.split(":");
+  if (parts.length < 2 || parts[0] !== "agent")
+    return null;
+  const id = parts[1];
+  return id && id.length > 0 ? id : null;
+}
 async function sendSystemMessage(state, agentId, message, idempotencyKey, log) {
   if (!state.runCommand) {
     log(`[cold-start] sendSystemMessage ${idempotencyKey}: skipped — runCommand not available`);
@@ -2176,6 +2194,11 @@ async function transition(state, runtime, log, trigger) {
         return cur;
       }
       if (cur.phase === "AWAITING_BASELINE") {
+        const specialistId = specialistIdFromSessionKey(cur.actionSessionKey);
+        if (specialistId && !specialistHasAnySurface(state, specialistId)) {
+          log(`[cold-start] ${specialistId} replied in AWAITING_BASELINE with no surface ` + `attributed — [system:start] contract violation (expected a warmup-* input surface)`);
+          return enterFailed(state, log, "agent_produced_no_surface");
+        }
         return cur;
       }
       return cur;
@@ -5289,9 +5312,12 @@ import * as fs7 from "node:fs";
 import * as os5 from "node:os";
 import * as path9 from "node:path";
 var AGENTLIFE_DIR = path9.join(os5.homedir(), ".openclaw", "agentlife");
-var DEVICE_FILE = path9.join(AGENTLIFE_DIR, "device.json");
 var TUNNEL_FILE = path9.join(AGENTLIFE_DIR, "tunnel.json");
 var BIN_DIR = path9.join(AGENTLIFE_DIR, "bin");
+var PAIR_REQUEST_MARKER = path9.join(AGENTLIFE_DIR, "pair-requested");
+var IDENTITY_DIR = path9.join(os5.homedir(), ".agentlife");
+var DEVICE_FILE = path9.join(IDENTITY_DIR, "device.json");
+var LEGACY_DEVICE_FILE = path9.join(AGENTLIFE_DIR, "device.json");
 var CLOUDFLARED_BIN = os5.platform() === "win32" ? "cloudflared.exe" : "cloudflared";
 var CLOUDFLARED_PATH = path9.join(BIN_DIR, CLOUDFLARED_BIN);
 var API_BASE = process.env.AGENTLIFE_API_BASE || "https://api.agentlife.app";
@@ -5306,9 +5332,12 @@ function createInitialState() {
     tunnelInfo: null,
     process: null,
     restartTimer: null,
+    provisionRetryTimer: null,
     stopped: false,
     readyPromise: promise,
-    readyResolve: resolver
+    readyResolve: resolver,
+    inFlight: null,
+    binPath: null
   };
 }
 var state = createInitialState();
@@ -5336,6 +5365,10 @@ function stopCloudflaredSupervisor() {
     clearTimeout(state.restartTimer);
     state.restartTimer = null;
   }
+  if (state.provisionRetryTimer) {
+    clearTimeout(state.provisionRetryTimer);
+    state.provisionRetryTimer = null;
+  }
   if (state.process) {
     try {
       state.process.kill("SIGTERM");
@@ -5344,10 +5377,30 @@ function stopCloudflaredSupervisor() {
   }
 }
 async function bootstrap() {
-  const result = await doBootstrap();
-  state.tunnelInfo = result;
+  const result = await runBootstrap();
   state.readyResolve(result);
 }
+async function runBootstrap() {
+  if (state.inFlight)
+    return state.inFlight;
+  const promise = doBootstrap().then((result) => {
+    if (result)
+      state.tunnelInfo = result;
+    return result;
+  }).finally(() => {
+    state.inFlight = null;
+  });
+  state.inFlight = promise;
+  return promise;
+}
+function triggerProvision() {
+  if (state.stopped)
+    return;
+  requestPair();
+  runBootstrap().catch((err) => {
+    console.warn("[cloudflared-supervisor] triggered provision failed:", err?.message ?? err);
+  });
+}
 async function doBootstrap() {
   ensureDirs();
   const identity = loadOrCreateDeviceIdentity();
@@ -5357,29 +5410,84 @@ async function doBootstrap() {
     return null;
   }
   let tunnelInfo = loadCachedTunnel();
-  if (!tunnelInfo || Date.now() - tunnelInfo.provisionedAt > 24 * 60 * 60 * 1000) {
+  if (!tunnelInfo) {
+    if (!isPairRequested()) {
+      console.log("[cloudflared-supervisor] no tunnel cached and no pair request — staying idle (LAN-only)");
+      return null;
+    }
+    console.log("[cloudflared-supervisor] pair requested — provisioning fresh tunnel");
     tunnelInfo = await provisionTunnel(identity);
     if (!tunnelInfo) {
-      console.warn("[cloudflared-supervisor] provisioning failed — tunnel disabled (LAN-only mode)");
+      console.log("[cloudflared-supervisor] provision attempt did not yield a tunnel — will retry on next pair request");
       return null;
     }
     persistTunnel(tunnelInfo);
+    clearPairRequest();
+  } else if (isPairRequested()) {
+    console.log("[cloudflared-supervisor] pair requested with cache present — re-provisioning");
+    const refreshed = await provisionTunnel(identity);
+    if (refreshed) {
+      tunnelInfo = refreshed;
+      persistTunnel(tunnelInfo);
+    } else {
+      console.warn("[cloudflared-supervisor] re-provision failed — keeping cached tunnel");
+    }
+    clearPairRequest();
   }
   console.log(`[cloudflared-supervisor] tunnel ready: ${tunnelInfo.tunnelUrl}`);
   startCloudflaredProcess(binPath, tunnelInfo.tunnelToken);
   return tunnelInfo;
 }
+function isPairRequested() {
+  return fs7.existsSync(PAIR_REQUEST_MARKER);
+}
+function requestPair() {
+  try {
+    if (!fs7.existsSync(AGENTLIFE_DIR))
+      fs7.mkdirSync(AGENTLIFE_DIR, { recursive: true, mode: 448 });
+    fs7.writeFileSync(PAIR_REQUEST_MARKER, String(Date.now()), { mode: 384 });
+  } catch (err) {
+    console.warn(`[cloudflared-supervisor] failed to write pair-request marker: ${err?.message ?? err}`);
+  }
+}
+function clearPairRequest() {
+  try {
+    fs7.unlinkSync(PAIR_REQUEST_MARKER);
+  } catch {}
+}
+function parseRetryAfter(value) {
+  const n = value == null ? NaN : parseInt(value.trim(), 10);
+  if (!Number.isFinite(n) || n < 1)
+    return 60;
+  return Math.min(n, 3600);
+}
+function scheduleProvisionRetry(delayMs) {
+  if (state.stopped)
+    return;
+  if (state.provisionRetryTimer) {
+    clearTimeout(state.provisionRetryTimer);
+    state.provisionRetryTimer = null;
+  }
+  state.provisionRetryTimer = setTimeout(() => {
+    state.provisionRetryTimer = null;
+    if (state.stopped || state.tunnelInfo)
+      return;
+    triggerProvision();
+  }, delayMs);
+}
 function ensureDirs() {
   if (!fs7.existsSync(AGENTLIFE_DIR))
     fs7.mkdirSync(AGENTLIFE_DIR, { recursive: true, mode: 448 });
   if (!fs7.existsSync(BIN_DIR))
     fs7.mkdirSync(BIN_DIR, { recursive: true, mode: 448 });
+  if (!fs7.existsSync(IDENTITY_DIR))
+    fs7.mkdirSync(IDENTITY_DIR, { recursive: true, mode: 448 });
 }
-function loadDeviceIdentity() {
-  if (!fs7.existsSync(DEVICE_FILE))
+function readIdentityFile(filePath) {
+  if (!fs7.existsSync(filePath))
     return null;
   try {
-    const raw = fs7.readFileSync(DEVICE_FILE, "utf-8");
+    const raw = fs7.readFileSync(filePath, "utf-8");
     const parsed = JSON.parse(raw);
     if (typeof parsed.deviceId === "string" && typeof parsed.deviceSecret === "string") {
       return { deviceId: parsed.deviceId, deviceSecret: parsed.deviceSecret };
@@ -5389,10 +5497,35 @@ function loadDeviceIdentity() {
     return null;
   }
 }
+function loadDeviceIdentity() {
+  const current = readIdentityFile(DEVICE_FILE);
+  if (current)
+    return current;
+  const legacy = readIdentityFile(LEGACY_DEVICE_FILE);
+  if (!legacy)
+    return null;
+  try {
+    if (!fs7.existsSync(IDENTITY_DIR))
+      fs7.mkdirSync(IDENTITY_DIR, { recursive: true, mode: 448 });
+    fs7.writeFileSync(DEVICE_FILE, JSON.stringify(legacy, null, 2), { mode: 384 });
+    try {
+      fs7.chmodSync(DEVICE_FILE, 384);
+    } catch {}
+    try {
+      fs7.unlinkSync(LEGACY_DEVICE_FILE);
+    } catch {}
+    console.log(`[cloudflared-supervisor] migrated device.json to ${DEVICE_FILE}`);
+  } catch (err) {
+    console.warn(`[cloudflared-supervisor] device.json migration failed: ${err?.message ?? err}`);
+  }
+  return legacy;
+}
 function loadOrCreateDeviceIdentity() {
   const existing = loadDeviceIdentity();
   if (existing)
     return existing;
+  if (!fs7.existsSync(IDENTITY_DIR))
+    fs7.mkdirSync(IDENTITY_DIR, { recursive: true, mode: 448 });
   const identity = {
     deviceId: crypto2.randomUUID(),
     deviceSecret: crypto2.randomBytes(32).toString("base64url")
@@ -5436,6 +5569,12 @@ async function provisionTunnel(identity) {
     });
     if (!response.ok) {
       const body = await response.text();
+      if (response.status === 503) {
+        const retryAfter = parseRetryAfter(response.headers.get("retry-after"));
+        console.warn(`[cloudflared-supervisor] provision rate-limited by server (HTTP 503); ` + `scheduling retry in ${retryAfter}s`);
+        scheduleProvisionRetry(retryAfter * 1000);
+        return null;
+      }
       console.warn(`[cloudflared-supervisor] provision HTTP ${response.status}: ${body.slice(0, 200)}`);
       return null;
     }
@@ -5718,6 +5857,8 @@ function registerWebApp(api) {
           return true;
         const bootstrapToken = mintBootstrapToken();
         const tunnelInfo = getTunnelInfo();
+        if (!tunnelInfo?.tunnelUrl)
+          triggerProvision();
         const payload = { bootstrapToken };
         if (tunnelInfo?.tunnelUrl)
           payload.tunnelUrl = tunnelInfo.tunnelUrl;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentlife",
-  "version": "1.4.1",
+  "version": "1.5.1",
   "type": "module",
   "scripts": {
     "build": "bun build index.ts --outfile dist/index.js --target node --external openclaw/plugin-sdk",