helloloop 0.8.4 → 0.8.5

package/src/runner_execute_task.mjs

@@ -3,6 +3,7 @@ import path from "node:path";
 import { rememberEngineSelection } from "./engine_selection.mjs";
 import { getEngineDisplayName } from "./engine_metadata.mjs";
 import { ensureDir, nowIso, writeText } from "./common.mjs";
+import { isHostLeaseAlive } from "./host_lease.mjs";
 import { saveBacklog } from "./config.mjs";
 import { reviewTaskCompletion } from "./completion_review.mjs";
 import { updateTask } from "./backlog.mjs";
@@ -13,6 +14,7 @@ import {
   buildBlockedResult,
   buildDoneResult,
   buildFailureResult,
+  buildStoppedResult,
   bumpFailureForNextStrategy,
   recordFailure,
   resolveExecutionSetup,
@@ -25,6 +27,18 @@ import {
 } from "./runner_status.mjs";
 
 async function handleEngineFailure(execution, state, attemptState, engineResult) {
+  if (engineResult.leaseExpired) {
+    return {
+      action: "return",
+      result: buildStoppedResult(
+        execution,
+        "host-lease-stopped",
+        engineResult.leaseReason || "检测到宿主窗口已关闭，当前任务已停止并回退为待处理。",
+        state.failureHistory.length,
+        state.engineResolution,
+      ),
+    };
+  }
   const previousFailure = buildFailureSummary("engine", {
     ...engineResult,
     displayName: getEngineDisplayName(state.engineResolution.engine),
@@ -49,6 +63,18 @@ async function handleEngineFailure(execution, state, attemptState, engineResult)
 }
 
 function handleVerifyFailure(execution, state, attemptState, verifyResult) {
+  if (verifyResult.failed?.leaseExpired) {
+    return {
+      action: "return",
+      result: buildStoppedResult(
+        execution,
+        "host-lease-stopped",
+        verifyResult.failed.leaseReason || "检测到宿主窗口已关闭，验证阶段已停止，当前任务已回退为待处理。",
+        state.failureHistory.length,
+        state.engineResolution,
+      ),
+    };
+  }
   const previousFailure = buildFailureSummary("verify", verifyResult);
   recordFailure(state.failureHistory, attemptState.strategyIndex, attemptState.attemptIndex, "verify", previousFailure);
 
@@ -68,6 +94,18 @@ function handleVerifyFailure(execution, state, attemptState, verifyResult) {
 }
 
 async function handleReviewFailure(execution, state, attemptState, reviewResult) {
+  if (reviewResult.raw?.leaseExpired) {
+    return {
+      action: "return",
+      result: buildStoppedResult(
+        execution,
+        "host-lease-stopped",
+        reviewResult.raw.leaseReason || "检测到宿主窗口已关闭，任务复核已停止，当前任务已回退为待处理。",
+        state.failureHistory.length,
+        state.engineResolution,
+      ),
+    };
+  }
   const previousFailure = reviewResult.summary;
   recordFailure(state.failureHistory, attemptState.strategyIndex, attemptState.attemptIndex, "task_review", previousFailure);
   return {
@@ -107,7 +145,12 @@ function handleIncompleteReview(execution, state, attemptState, reviewResult) {
 }
 
 async function handleVerifyAndReview(execution, state, attemptState, engineResult) {
-  const verifyResult = await runVerifyCommands(execution.context, execution.verifyCommands, attemptState.attemptDir);
+  const verifyResult = await runVerifyCommands(
+    execution.context,
+    execution.verifyCommands,
+    attemptState.attemptDir,
+    { hostLease: execution.hostLease },
+  );
   if (!verifyResult.ok) {
     return handleVerifyFailure(execution, state, attemptState, verifyResult);
   }
@@ -123,6 +166,7 @@ async function handleVerifyAndReview(execution, state, attemptState, engineResul
     verifyResult,
     runDir: attemptState.attemptDir,
     policy: execution.policy,
+    hostLease: execution.hostLease,
   });
   if (!reviewResult.ok) {
     return handleReviewFailure(execution, state, attemptState, reviewResult);
@@ -163,6 +207,7 @@ async function runAttempt(execution, state, attemptState) {
     prompt,
     runDir: attemptState.attemptDir,
     policy: execution.policy,
+    hostLease: execution.hostLease,
   });
   if (!engineResult.ok) {
     return handleEngineFailure(execution, state, attemptState, engineResult);
@@ -175,6 +220,15 @@ export async function executeSingleTask(context, options = {}) {
   if (execution.idleResult) {
     return execution.idleResult;
   }
+  if (!isHostLeaseAlive(execution.hostLease)) {
+    return buildStoppedResult(
+      execution,
+      "host-lease-stopped",
+      "检测到宿主窗口已关闭，当前任务未继续执行，并已回退为待处理。",
+      0,
+      execution.engineResolution,
+    );
+  }
   if (!execution.engineResolution.ok) {
     return {
       ok: false,

package/src/runner_execution_support.mjs

@@ -70,6 +70,7 @@ export async function resolveExecutionSetup(context, options = {}) {
     maxAttemptsPerStrategy,
     maxStrategies: policy.stopOnFailure ? 1 : configuredStrategies,
     engineResolution,
+    hostLease: options.hostLease || null,
   };
 }
 
@@ -84,6 +85,19 @@ function updateTaskAndBuildResult(execution, status, result) {
   return result;
 }
 
+export function buildStoppedResult(execution, kind, summary, attempts, engineResolution) {
+  return updateTaskAndBuildResult(execution, "pending", {
+    ok: false,
+    stopped: true,
+    kind,
+    task: execution.task,
+    runDir: execution.runDir,
+    summary,
+    attempts,
+    engineResolution,
+  });
+}
+
 export function buildFailureResult(execution, kind, summary, attempts, engineResolution) {
   return updateTaskAndBuildResult(execution, "failed", {
     ok: false,

package/src/runner_status.mjs

@@ -1,8 +1,9 @@
 import path from "node:path";
 
-import { sanitizeId, tailText, timestampForFile } from "./common.mjs";
+import { fileExists, readJson, sanitizeId, tailText, timestampForFile } from "./common.mjs";
 import { renderTaskSummary, selectNextTask, summarizeBacklog } from "./backlog.mjs";
 import { loadBacklog } from "./config.mjs";
+import { renderHostLeaseLabel } from "./host_lease.mjs";
 
 export function makeRunDir(context, taskId) {
   return path.join(context.runsDir, `${timestampForFile()}-${sanitizeId(taskId)}`);
@@ -86,6 +87,9 @@ export function renderStatusText(context, options = {}) {
   const backlog = loadBacklog(context);
   const summary = summarizeBacklog(backlog);
   const nextTask = selectNextTask(backlog, options);
+  const supervisor = fileExists(context.supervisorStateFile)
+    ? readJson(context.supervisorStateFile)
+    : null;
 
   return [
     "HelloLoop 状态",
@@ -97,6 +101,13 @@ export function renderStatusText(context, options = {}) {
     `进行中：${summary.inProgress}`,
     `失败：${summary.failed}`,
     `阻塞：${summary.blocked}`,
+    ...(supervisor?.status
+      ? [
+        `后台会话：${supervisor.status}`,
+        `后台会话 ID：${supervisor.sessionId || "unknown"}`,
+        `后台租约：${renderHostLeaseLabel(supervisor.lease)}`,
+      ]
+      : []),
     "",
     nextTask ? "下一任务：" : "下一任务：无",
     nextTask ? renderTaskSummary(nextTask) : "",

package/src/runtime_engine_support.mjs

@@ -0,0 +1,342 @@
+import fs from "node:fs";
+import path from "node:path";
+
+import { nowIso, writeText } from "./common.mjs";
+import { getEngineDisplayName } from "./engine_metadata.mjs";
+import {
+  buildClaudeArgs,
+  buildCodexArgs,
+  buildGeminiArgs,
+  runChild,
+} from "./engine_process_support.mjs";
+import { sendRuntimeStopNotification } from "./email_notification.mjs";
+import { loadGlobalConfig } from "./global_config.mjs";
+import {
+  buildEngineHealthProbePrompt,
+  classifyRuntimeRecoveryFailure,
+} from "./runtime_recovery.mjs";
+import { isHostLeaseAlive } from "./host_lease.mjs";
+
+export async function sleepWithLease(ms, hostLease = null) {
+  const totalMs = Math.max(0, Number(ms || 0));
+  if (totalMs <= 0) {
+    return isHostLeaseAlive(hostLease);
+  }
+
+  const startedAt = Date.now();
+  while (Date.now() - startedAt < totalMs) {
+    if (!isHostLeaseAlive(hostLease)) {
+      return false;
+    }
+    const remaining = totalMs - (Date.now() - startedAt);
+    await new Promise((resolve) => {
+      setTimeout(resolve, Math.min(1000, Math.max(50, remaining)));
+    });
+  }
+  return isHostLeaseAlive(hostLease);
+}
+
+export function buildHostLeaseStoppedResult(reason) {
+  return {
+    ok: false,
+    code: 1,
+    stdout: "",
+    stderr: reason,
+    signal: "",
+    startedAt: nowIso(),
+    finishedAt: nowIso(),
+    idleTimeout: false,
+    watchdogTriggered: false,
+    watchdogReason: "",
+    leaseExpired: true,
+    leaseReason: reason,
+  };
+}
+
+export function createRuntimeStatusWriter(runtimeStatusFile, baseState) {
+  return function writeRuntimeStatus(status, extra = {}) {
+    writeJson(runtimeStatusFile, {
+      ...baseState,
+      ...extra,
+      status,
+      updatedAt: nowIso(),
+    });
+  };
+}
+
+function writeJson(filePath, value) {
+  writeText(filePath, `${JSON.stringify(value, null, 2)}\n`);
+}
+
+export function writeEngineRunArtifacts(runDir, prefix, result, finalMessage) {
+  writeText(path.join(runDir, `${prefix}-stdout.log`), result.stdout);
+  writeText(path.join(runDir, `${prefix}-stderr.log`), result.stderr);
+  writeText(path.join(runDir, `${prefix}-summary.txt`), [
+    `ok=${result.ok}`,
+    `code=${result.code}`,
+    `finished_at=${nowIso()}`,
+    "",
+    finalMessage,
+  ].join("\n"));
+}
+
+export function resolveEnginePolicy(policy = {}, engine) {
+  if (engine === "codex") {
+    return policy.codex || {};
+  }
+  if (engine === "claude") {
+    return policy.claude || {};
+  }
+  if (engine === "gemini") {
+    return policy.gemini || {};
+  }
+  return {};
+}
+
+function buildEngineArgs({
+  engine,
+  context,
+  resolvedPolicy,
+  executionMode,
+  outputSchemaFile,
+  ephemeral,
+  skipGitRepoCheck,
+  lastMessageFile,
+  probeMode = false,
+}) {
+  if (engine === "codex") {
+    return buildCodexArgs({
+      context,
+      model: resolvedPolicy.model,
+      sandbox: resolvedPolicy.sandbox,
+      dangerouslyBypassSandbox: resolvedPolicy.dangerouslyBypassSandbox,
+      jsonOutput: probeMode ? false : (resolvedPolicy.jsonOutput !== false),
+      outputSchemaFile: probeMode ? "" : outputSchemaFile,
+      ephemeral,
+      skipGitRepoCheck,
+      lastMessageFile,
+    });
+  }
+
+  if (engine === "claude") {
+    return buildClaudeArgs({
+      model: resolvedPolicy.model,
+      outputSchemaFile: probeMode ? "" : outputSchemaFile,
+      executionMode: probeMode ? "execute" : executionMode,
+      policy: resolvedPolicy,
+    });
+  }
+
+  return buildGeminiArgs({
+    model: resolvedPolicy.model,
+    executionMode: probeMode ? "execute" : executionMode,
+    policy: resolvedPolicy,
+  });
+}
+
+function readEngineFinalMessage(engine, lastMessageFile, result) {
+  if (engine === "codex") {
+    return fs.existsSync(lastMessageFile)
+      ? fs.readFileSync(lastMessageFile, "utf8").trim()
+      : "";
+  }
+  return String(result.stdout || "").trim();
+}
+
+export async function runEngineAttempt({
+  engine,
+  invocation,
+  context,
+  prompt,
+  runDir,
+  attemptPrefix,
+  resolvedPolicy,
+  executionMode,
+  outputSchemaFile,
+  env,
+  recoveryPolicy,
+  writeRuntimeStatus,
+  recoveryCount,
+  recoveryHistory,
+  hostLease,
+  ephemeral = false,
+  skipGitRepoCheck = false,
+  probeMode = false,
+}) {
+  const attemptPromptFile = path.join(runDir, `${attemptPrefix}-prompt.md`);
+  const attemptLastMessageFile = path.join(runDir, `${attemptPrefix}-last-message.txt`);
+
+  if (invocation.error) {
+    const result = {
+      ok: false,
+      code: 1,
+      stdout: "",
+      stderr: invocation.error,
+      signal: "",
+      startedAt: nowIso(),
+      finishedAt: nowIso(),
+      idleTimeout: false,
+      watchdogTriggered: false,
+      watchdogReason: "",
+    };
+    writeText(attemptPromptFile, prompt);
+    writeEngineRunArtifacts(runDir, attemptPrefix, result, "");
+    return {
+      result,
+      finalMessage: "",
+      attemptPrefix,
+    };
+  }
+
+  const finalArgs = [
+    ...invocation.argsPrefix,
+    ...buildEngineArgs({
+      engine,
+      context,
+      resolvedPolicy,
+      executionMode,
+      outputSchemaFile,
+      ephemeral,
+      skipGitRepoCheck,
+      lastMessageFile: attemptLastMessageFile,
+      probeMode,
+    }),
+  ];
+
+  writeRuntimeStatus(probeMode ? "probe_running" : (recoveryCount > 0 ? "recovering" : "running"), {
+    attemptPrefix,
+    recoveryCount,
+    recoveryHistory,
+  });
+
+  const result = await runChild(invocation.command, finalArgs, {
+    cwd: context.repoRoot,
+    stdin: prompt,
+    env,
+    shell: invocation.shell,
+    heartbeatIntervalMs: recoveryPolicy.heartbeatIntervalSeconds * 1000,
+    stallWarningMs: recoveryPolicy.stallWarningSeconds * 1000,
+    maxIdleMs: recoveryPolicy.maxIdleSeconds * 1000,
+    killGraceMs: recoveryPolicy.killGraceSeconds * 1000,
+    onHeartbeat(payload) {
+      writeRuntimeStatus(payload.status, {
+        attemptPrefix,
+        recoveryCount,
+        recoveryHistory,
+        heartbeat: payload,
+      });
+    },
+    shouldKeepRunning() {
+      return isHostLeaseAlive(hostLease);
+    },
+    leaseStopReason: "检测到宿主窗口已关闭，HelloLoop 已停止当前引擎进程。",
+  });
+  const finalMessage = readEngineFinalMessage(engine, attemptLastMessageFile, result);
+
+  writeText(attemptPromptFile, prompt);
+  writeEngineRunArtifacts(runDir, attemptPrefix, result, finalMessage);
+
+  return {
+    result,
+    finalMessage,
+    attemptPrefix,
+  };
+}
+
+export async function runEngineHealthProbe({
+  engine,
+  invocation,
+  context,
+  runDir,
+  resolvedPolicy,
+  recoveryPolicy,
+  writeRuntimeStatus,
+  recoveryCount,
+  recoveryHistory,
+  hostLease,
+  env,
+  probeIndex,
+}) {
+  const probePrompt = buildEngineHealthProbePrompt(engine);
+  const attemptPrefix = `${engine}-probe-${String(probeIndex).padStart(2, "0")}`;
+  writeRuntimeStatus("probe_waiting", {
+    attemptPrefix,
+    recoveryCount,
+    recoveryHistory,
+  });
+  const attempt = await runEngineAttempt({
+    engine,
+    invocation,
+    context,
+    prompt: probePrompt,
+    runDir,
+    attemptPrefix,
+    resolvedPolicy,
+    executionMode: "execute",
+    outputSchemaFile: "",
+    env,
+    recoveryPolicy: {
+      ...recoveryPolicy,
+      maxIdleSeconds: recoveryPolicy.healthProbeTimeoutSeconds,
+    },
+    writeRuntimeStatus,
+    recoveryCount,
+    recoveryHistory,
+    hostLease,
+    ephemeral: true,
+    skipGitRepoCheck: true,
+    probeMode: true,
+  });
+
+  return {
+    ...attempt,
+    failure: classifyRuntimeRecoveryFailure({
+      result: {
+        ...attempt.result,
+        finalMessage: attempt.finalMessage,
+      },
+    }),
+  };
+}
+
+export async function maybeSendStopNotification({
+  context,
+  runDir,
+  engine,
+  executionMode,
+  failure,
+  result,
+  recoveryHistory,
+}) {
+  try {
+    return await sendRuntimeStopNotification({
+      globalConfig: loadGlobalConfig(),
+      context,
+      engine: getEngineDisplayName(engine),
+      phase: executionMode === "analyze" ? "分析/复核" : "执行",
+      failure,
+      result,
+      recoveryHistory,
+      runDir,
+    });
+  } catch (error) {
+    return {
+      attempted: true,
+      delivered: false,
+      reason: String(error?.message || error || "邮件发送失败。"),
+    };
+  }
+}
+
+export function buildNotificationNote(notificationResult) {
+  if (!notificationResult) {
+    return "";
+  }
+  if (notificationResult.delivered) {
+    return `告警邮件已发送：${(notificationResult.recipients || []).join(", ")}`;
+  }
+  if (notificationResult.attempted) {
+    return `告警邮件发送失败：${notificationResult.reason || "未知原因"}`;
+  }
+  return `未发送告警邮件：${notificationResult.reason || "未启用"}`;
+}