@kynver-app/runtime 0.1.13 → 0.1.16

package/dist/index.js

@@ -208,6 +208,18 @@ async function resolveCallbackSecretWithMint(argsSecret, agentOsId, opts) {
     "requires --secret, KYNVER_RUNNER_TOKEN, a scoped runner token (`kynver runner credential`), ~/.kynver/credentials runnerToken, KYNVER_API_KEY with an API base URL to mint one, or (legacy) KYNVER_RUNTIME_SECRET / OPENCLAW_CRON_SECRET"
   );
 }
+async function refreshRunnerToken(agentOsId, opts) {
+  const apiKey = loadApiKey();
+  const baseUrl = resolveConfiguredBaseUrl(opts?.baseUrl);
+  if (!apiKey || !agentOsId || !baseUrl) return null;
+  try {
+    const token = await fetchRunnerCredential(agentOsId, { baseUrl, apiKey });
+    saveRunnerToken(agentOsId, token);
+    return token;
+  } catch {
+    return null;
+  }
+}
 async function fetchRunnerCredential(agentOsId, opts) {
   const apiKey = opts?.apiKey || loadApiKey();
   if (!apiKey) throw new Error("API key required \u2014 run `kynver login` first");
@@ -1483,6 +1495,34 @@ async function sweepRun(args) {
 
 // src/worker-ops.ts
 import path11 from "node:path";
+async function postCompletion(url, secret, body) {
+  const res = await fetch(url, {
+    method: "POST",
+    headers: buildHarnessCallbackHeaders(secret),
+    body: JSON.stringify(body)
+  });
+  let parsed = null;
+  try {
+    parsed = await res.json();
+  } catch {
+    parsed = null;
+  }
+  return { ok: res.ok, status: res.status, parsed };
+}
+function completionErrorText(parsed) {
+  if (parsed && typeof parsed === "object") {
+    const err = parsed.error;
+    if (typeof err === "string" && err.trim()) return err.trim();
+  }
+  return void 0;
+}
+function persistCompletionBlocker(worker, reason) {
+  const current = worker.completionBlocker;
+  if ((current ?? void 0) === (reason ?? void 0)) return;
+  if (reason) worker.completionBlocker = reason;
+  else delete worker.completionBlocker;
+  saveWorker(worker.runId, worker);
+}
 async function tryCompleteWorker(args) {
   const worker = loadWorker(String(args.run), String(args.name));
   const status = computeWorkerStatus(worker);
@@ -1495,7 +1535,8 @@ async function tryCompleteWorker(args) {
     return { ok: true, skipped: true, reason: "worker-not-finished" };
   }
   const base = resolveBaseUrl(args.baseUrl ? String(args.baseUrl) : void 0);
-  const secret = await resolveCallbackSecretWithMint(args.secret ? String(args.secret) : void 0, agentOsId, { baseUrl: base });
+  const explicitSecret = args.secret ? String(args.secret) : void 0;
+  let secret = await resolveCallbackSecretWithMint(explicitSecret, agentOsId, { baseUrl: base });
   const url = `${base}/api/agent-os/by-id/${encodeURIComponent(agentOsId)}/harness/completion`;
   const body = {
     source: "openclaw-harness",
@@ -1507,18 +1548,23 @@ async function tryCompleteWorker(args) {
     finishedAt: status.lastActivityAt || (/* @__PURE__ */ new Date()).toISOString(),
     status
   };
-  const res = await fetch(url, {
-    method: "POST",
-    headers: buildHarnessCallbackHeaders(secret),
-    body: JSON.stringify(body)
-  });
-  let parsed = null;
-  try {
-    parsed = await res.json();
-  } catch {
-    parsed = null;
+  let result = await postCompletion(url, secret, body);
+  if ((result.status === 401 || result.status === 403) && !explicitSecret) {
+    const refreshed = await refreshRunnerToken(agentOsId, { baseUrl: base });
+    if (refreshed && refreshed !== secret) {
+      secret = refreshed;
+      result = await postCompletion(url, secret, body);
+    }
   }
-  return { ok: res.ok, httpStatus: res.status, response: parsed };
+  if (result.ok) {
+    persistCompletionBlocker(worker, void 0);
+    return { ok: true, httpStatus: result.status, response: result.parsed };
+  }
+  const authRejected = result.status === 401 || result.status === 403;
+  const detail = completionErrorText(result.parsed) ?? (authRejected ? "runner token unauthorized" : "non-2xx response");
+  const reason = authRejected ? `completion replay rejected (${result.status}): ${detail}` : `completion replay failed (${result.status}): ${detail}`;
+  persistCompletionBlocker(worker, reason);
+  return { ok: false, httpStatus: result.status, response: result.parsed, completionBlocked: true };
 }
 async function completeWorker(args) {
   try {
@@ -1586,11 +1632,13 @@ function runStatus(args) {
       return { worker: name, status: "missing", attention: "needs_attention", attentionReason: "worker.json not found" };
     }
     const status = computeWorkerStatus(worker, { base: run.base });
+    const rawBlocker = worker.completionBlocker;
+    const completionBlocker = typeof rawBlocker === "string" && rawBlocker ? rawBlocker : void 0;
     return {
       worker: status.worker,
-      status: status.status,
-      attention: status.attention.state,
-      attentionReason: status.attention.reason,
+      status: completionBlocker ? "blocked" : status.status,
+      attention: completionBlocker ? "blocked" : status.attention.state,
+      attentionReason: completionBlocker ?? status.attention.reason,
       pid: status.pid,
       alive: status.alive,
       currentTool: status.currentTool,
@@ -1660,6 +1708,7 @@ function terminalStatusFor(run) {
   if (names.length === 0) return "failed";
   let anyAlive = false;
   let anyResult = false;
+  let anyCompletionBlocked = false;
   for (const name of names) {
     const worker = readJson(
       path12.join(runDirectory(run.id), "workers", safeSlug(name), "worker.json"),
@@ -1671,9 +1720,13 @@ function terminalStatusFor(run) {
       anyAlive = true;
       break;
     }
+    if (typeof worker.completionBlocker === "string" && worker.completionBlocker) {
+      anyCompletionBlocked = true;
+    }
     if (status.finalResult) anyResult = true;
   }
   if (anyAlive) return null;
+  if (anyCompletionBlocked) return null;
   return anyResult ? "completed" : "failed";
 }
 function finalizeStaleRuns() {
@@ -1772,9 +1825,10 @@ async function completeFinishedWorkers(runId, args) {
       path14.join(runDirectory(run.id), "workers", safeSlug(name), "worker.json"),
       void 0
     );
-    if (!worker?.dispatched || !worker.taskId) continue;
+    if (!worker?.taskId) continue;
     const status = computeWorkerStatus(worker);
     if (!isFinishedWorkerStatus(status)) continue;
+    if (!worker.dispatched && !status.finalResult) continue;
     const result = await tryCompleteWorker({
       run: runId,
       name,
@@ -1802,8 +1856,8 @@ async function runPipelineTick(args) {
   const agentOsId = String(required(String(args.agentOsId || ""), "--agent-os-id"));
   const execute = args.execute !== false && args.execute !== "false";
   runStatus({ run: runId });
-  const finalizedStaleRuns = finalizeStaleRuns();
   const completedWorkers = await completeFinishedWorkers(runId, args);
+  const finalizedStaleRuns = finalizeStaleRuns();
   const planProgressSync = await syncActiveWorkerPlanProgress(runId, args);
   const workspacePrefs = await fetchWorkspaceRuntimePreferences(agentOsId, args);
   const resourceGate = observeRunnerResourceGate({