helloloop 0.8.6 → 0.10.0

package/src/engine_event_parser_codex.mjs

@@ -0,0 +1,167 @@
+function normalizeWhitespace(value) {
+  return String(value || "").replace(/\s+/gu, " ").trim();
+}
+
+function stripMarkdown(value) {
+  return normalizeWhitespace(String(value || "")
+    .replace(/\*\*(.*?)\*\*/gu, "$1")
+    .replace(/`([^`]+)`/gu, "$1")
+    .replace(/^#+\s*/gmu, ""));
+}
+
+function shorten(value, maxLength = 160) {
+  const text = normalizeWhitespace(value);
+  if (!text) {
+    return "";
+  }
+  return text.length <= maxLength ? text : `${text.slice(0, Math.max(0, maxLength - 1))}…`;
+}
+
+function summarizeText(value, maxLength = 160) {
+  const sections = String(value || "")
+    .replace(/\r\n/gu, "\n")
+    .split(/\n\s*\n/gu)
+    .map((item) => stripMarkdown(item))
+    .filter(Boolean);
+  return shorten(sections[0] || stripMarkdown(value), maxLength);
+}
+
+function normalizeExitCode(value) {
+  const code = Number(value);
+  return Number.isFinite(code) ? code : null;
+}
+
+function normalizeTodoItems(items) {
+  const normalized = Array.isArray(items)
+    ? items.map((item) => ({
+      text: shorten(item?.text || "", 140),
+      completed: item?.completed === true,
+    }))
+    : [];
+  const completed = normalized.filter((item) => item.completed).length;
+  return {
+    items: normalized,
+    total: normalized.length,
+    completed,
+    pending: Math.max(0, normalized.length - completed),
+  };
+}
+
+function normalizeChanges(changes) {
+  return Array.isArray(changes)
+    ? changes.map((change) => ({
+      path: String(change?.path || "").trim(),
+      kind: String(change?.kind || "update").trim() || "update",
+    }))
+    : [];
+}
+
+function buildFileChangeLabel(changes) {
+  if (!changes.length) {
+    return "文件变更";
+  }
+  if (changes.length === 1) {
+    const change = changes[0];
+    return `${change.kind} ${shorten(change.path, 100)}`;
+  }
+  return `${changes.length} 个文件变更`;
+}
+
+export function parseCodexJsonlEventLine(line) {
+  const payload = JSON.parse(line);
+  const type = String(payload?.type || "").trim();
+
+  if (type === "thread.started") {
+    return {
+      kind: "thread",
+      status: "started",
+      label: "线程已启动",
+      threadId: String(payload.thread_id || "").trim(),
+    };
+  }
+
+  if (type === "turn.started") {
+    return {
+      kind: "turn",
+      status: "started",
+      label: "轮次开始",
+    };
+  }
+
+  if (type === "turn.completed") {
+    return {
+      kind: "turn",
+      status: "completed",
+      label: "轮次完成",
+    };
+  }
+
+  if (!type.startsWith("item.")) {
+    return {
+      kind: "event",
+      status: "info",
+      label: shorten(type, 120) || "事件更新",
+    };
+  }
+
+  const item = payload.item || {};
+  const itemId = String(item.id || "").trim();
+  const itemStatus = type === "item.started"
+    ? "in_progress"
+    : (String(item.status || "").trim() || "completed");
+
+  if (item.type === "reasoning") {
+    const summary = summarizeText(item.text || "", 180);
+    return {
+      kind: "reasoning",
+      itemId,
+      status: itemStatus,
+      label: summary || "推理更新",
+      summary,
+    };
+  }
+
+  if (item.type === "todo_list") {
+    const todo = normalizeTodoItems(item.items);
+    return {
+      kind: "todo",
+      itemId,
+      status: itemStatus,
+      label: todo.total > 0
+        ? `待办 ${todo.completed}/${todo.total}`
+        : "待办清单更新",
+      todo,
+    };
+  }
+
+  if (item.type === "command_execution") {
+    const command = shorten(item.command || "", 220);
+    return {
+      kind: "command",
+      itemId,
+      status: itemStatus,
+      label: command || "命令执行",
+      command,
+      exitCode: normalizeExitCode(item.exit_code),
+      outputSummary: summarizeText(item.aggregated_output || "", 160),
+    };
+  }
+
+  if (item.type === "file_change") {
+    const changes = normalizeChanges(item.changes);
+    return {
+      kind: "file_change",
+      itemId,
+      status: itemStatus,
+      label: buildFileChangeLabel(changes),
+      changes,
+    };
+  }
+
+  return {
+    kind: String(item.type || "item").trim() || "item",
+    itemId,
+    status: itemStatus,
+    label: summarizeText(item.text || item.command || item.type || type, 160) || "活动更新",
+  };
+}

package/src/engine_process_support.mjs

@@ -26,6 +26,7 @@ export function runChild(command, args, options = {}) {
       },
       stdio: ["pipe", "pipe", "pipe"],
       shell: Boolean(options.shell),
+      windowsHide: process.platform === "win32",
     });
 
     let stdout = "";
@@ -121,17 +122,21 @@ export function runChild(command, args, options = {}) {
     emitHeartbeat("running");
 
     child.stdout.on("data", (chunk) => {
-      stdout += chunk.toString();
+      const text = chunk.toString();
+      stdout += text;
       stdoutBytes += chunk.length;
       lastOutputAt = Date.now();
       stallWarned = false;
+      options.onStdout?.(text);
       emitHeartbeat("running");
     });
     child.stderr.on("data", (chunk) => {
-      stderr += chunk.toString();
+      const text = chunk.toString();
+      stderr += text;
       stderrBytes += chunk.length;
       lastOutputAt = Date.now();
       stallWarned = false;
+      options.onStderr?.(text);
       emitHeartbeat("running");
     });
 

package/src/engine_selection.mjs

@@ -273,6 +273,30 @@ export async function resolveEngineSelection({
     };
   }
 
+  const recommendedEngine = recommendEngine({
+    hostContext,
+    availableEngines,
+    projectConfig,
+    userSettings,
+  });
+  if (!interactive && recommendedEngine) {
+    return buildResolution({
+      engine: recommendedEngine,
+      source: "remembered_default",
+      basis: [
+        buildRecommendationBasis({
+          hostContext,
+          projectConfig,
+          userSettings,
+          recommendedEngine,
+        }) || `继续沿用已确认过的默认执行引擎：${getEngineDisplayName(recommendedEngine)}。`,
+        "当前为无人值守续跑场景，HelloLoop 直接复用之前确认过的可用引擎。",
+      ],
+      hostContext,
+      probes,
+    });
+  }
+
   if (!interactive) {
     return {
       ok: false,

package/src/engine_selection_probe.mjs

@@ -1,7 +1,7 @@
 import { spawnSync } from "node:child_process";
 
 import { getEngineDisplayName, getEngineMetadata, listKnownEngines, normalizeEngineName } from "./engine_metadata.mjs";
-import { resolveCliInvocation } from "./shell_invocation.mjs";
+import { resolveCliInvocation, resolveCodexInvocation } from "./shell_invocation.mjs";
 
 function resolveExecutableOverride(policy = {}, engine) {
   const envExecutable = String(process.env[`HELLOLOOP_${String(engine || "").toUpperCase()}_EXECUTABLE`] || "").trim();
@@ -13,11 +13,14 @@ function resolveExecutableOverride(policy = {}, engine) {
 
 function probeEngineAvailability(engine, policy = {}) {
   const meta = getEngineMetadata(engine);
-  const invocation = resolveCliInvocation({
-    commandName: meta.commandName,
-    toolDisplayName: meta.displayName,
-    explicitExecutable: resolveExecutableOverride(policy, engine),
-  });
+  const explicitExecutable = resolveExecutableOverride(policy, engine);
+  const invocation = engine === "codex"
+    ? resolveCodexInvocation({ explicitExecutable })
+    : resolveCliInvocation({
+      commandName: meta.commandName,
+      toolDisplayName: meta.displayName,
+      explicitExecutable,
+    });
 
   if (invocation.error) {
     return {
@@ -30,6 +33,7 @@ function probeEngineAvailability(engine, policy = {}) {
   const result = spawnSync(invocation.command, [...invocation.argsPrefix, "--version"], {
     encoding: "utf8",
     shell: invocation.shell,
+    windowsHide: process.platform === "win32",
   });
   const ok = result.status === 0;
   return {

package/src/engine_selection_settings.mjs

@@ -3,6 +3,14 @@ import path from "node:path";
 
 import { fileExists, readJson, readText, timestampForFile, writeJson, writeText } from "./common.mjs";
 import { normalizeEngineName } from "./engine_metadata.mjs";
+import {
+  defaultObserverRetrySettings,
+  defaultSupervisorKeepAliveSettings,
+  defaultTerminalConcurrencySettings,
+  normalizeObserverRetrySettings,
+  normalizeSupervisorKeepAliveSettings,
+  normalizeTerminalConcurrencySettings,
+} from "./runtime_settings.mjs";
 
 function defaultEmailNotificationSettings() {
   return {
@@ -24,15 +32,6 @@ function defaultEmailNotificationSettings() {
   };
 }
 
-function defaultTerminalConcurrencySettings() {
-  return {
-    enabled: true,
-    visibleMax: 8,
-    backgroundMax: 8,
-    totalMax: 8,
-  };
-}
-
 function defaultUserSettings() {
   return {
     defaultEngine: "",
@@ -42,29 +41,30 @@ function defaultUserSettings() {
     },
     runtime: {
       terminalConcurrency: defaultTerminalConcurrencySettings(),
+      observerRetry: defaultObserverRetrySettings(),
+      supervisorKeepAlive: defaultSupervisorKeepAliveSettings(),
     },
   };
 }
 
-function cloneJsonValue(value) {
-  return JSON.parse(JSON.stringify(value));
-}
-
 function isPlainObject(value) {
   return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
 
-function syncValueBySchema(schemaValue, currentValue) {
-  if (!isPlainObject(schemaValue)) {
-    return currentValue === undefined ? cloneJsonValue(schemaValue) : currentValue;
-  }
+function normalizeString(value, fallback = "") {
+  return typeof value === "string" ? value.trim() : fallback;
+}
 
-  const source = isPlainObject(currentValue) ? currentValue : {};
-  const next = {};
-  for (const [key, childSchema] of Object.entries(schemaValue)) {
-    next[key] = syncValueBySchema(childSchema, Object.hasOwn(source, key) ? source[key] : undefined);
+function normalizeBoolean(value, fallback = false) {
+  return typeof value === "boolean" ? value : fallback;
+}
+
+function normalizePositiveInteger(value, fallback, minimum = 1) {
+  const numericValue = Number(value);
+  if (!Number.isInteger(numericValue) || numericValue < minimum) {
+    return fallback;
   }
-  return next;
+  return numericValue;
 }
 
 function mergeValueBySchema(schemaValue, baseValue, patchValue) {
@@ -87,16 +87,6 @@ function mergeValueBySchema(schemaValue, baseValue, patchValue) {
   return next;
 }
 
-export function syncUserSettingsShape(settings = {}) {
-  return syncValueBySchema(defaultUserSettings(), settings);
-}
-
-function readRawUserSettingsDocument(options = {}) {
-  const settingsFile = resolveUserSettingsFile(options.userSettingsFile);
-  const settings = fileExists(settingsFile) ? readJson(settingsFile) : {};
-  return syncUserSettingsShape(settings);
-}
-
 export function resolveUserSettingsHome() {
   return String(process.env.HELLOLOOP_HOME || "").trim()
     || path.join(os.homedir(), ".helloloop");
@@ -113,32 +103,51 @@ function normalizeEmailNotificationSettings(emailSettings = {}) {
   const smtp = emailSettings?.smtp || {};
 
   return {
-    ...defaults,
-    ...emailSettings,
+    enabled: normalizeBoolean(emailSettings?.enabled, defaults.enabled),
     to: Array.isArray(emailSettings?.to)
       ? emailSettings.to.map((item) => String(item || "").trim()).filter(Boolean)
-      : (typeof emailSettings?.to === "string" && emailSettings.to.trim() ? [emailSettings.to.trim()] : []),
+      : defaults.to,
+    from: normalizeString(emailSettings?.from, defaults.from),
     smtp: {
-      ...defaults.smtp,
-      ...smtp,
+      host: normalizeString(smtp?.host, defaults.smtp.host),
+      port: normalizePositiveInteger(smtp?.port, defaults.smtp.port),
+      secure: normalizeBoolean(smtp?.secure, defaults.smtp.secure),
+      starttls: normalizeBoolean(smtp?.starttls, defaults.smtp.starttls),
+      username: normalizeString(smtp?.username, defaults.smtp.username),
+      usernameEnv: normalizeString(smtp?.usernameEnv, defaults.smtp.usernameEnv),
+      password: typeof smtp?.password === "string" ? smtp.password : defaults.smtp.password,
+      passwordEnv: normalizeString(smtp?.passwordEnv, defaults.smtp.passwordEnv),
+      timeoutSeconds: normalizePositiveInteger(smtp?.timeoutSeconds, defaults.smtp.timeoutSeconds),
+      rejectUnauthorized: normalizeBoolean(smtp?.rejectUnauthorized, defaults.smtp.rejectUnauthorized),
     },
   };
 }
 
-export function loadUserSettingsDocument(options = {}) {
-  const settings = readRawUserSettingsDocument(options);
-
+export function syncUserSettingsShape(settings = {}) {
   return {
-    ...settings,
-    defaultEngine: normalizeEngineName(settings?.defaultEngine),
-    lastSelectedEngine: normalizeEngineName(settings?.lastSelectedEngine),
+    defaultEngine: normalizeEngineName(settings?.defaultEngine) || "",
+    lastSelectedEngine: normalizeEngineName(settings?.lastSelectedEngine) || "",
     notifications: {
-      ...(settings?.notifications || {}),
       email: normalizeEmailNotificationSettings(settings?.notifications?.email || {}),
     },
+    runtime: {
+      terminalConcurrency: normalizeTerminalConcurrencySettings(settings?.runtime?.terminalConcurrency || {}),
+      observerRetry: normalizeObserverRetrySettings(settings?.runtime?.observerRetry || {}),
+      supervisorKeepAlive: normalizeSupervisorKeepAliveSettings(settings?.runtime?.supervisorKeepAlive || {}),
+    },
   };
 }
 
+function readRawUserSettingsDocument(options = {}) {
+  const settingsFile = resolveUserSettingsFile(options.userSettingsFile);
+  const settings = fileExists(settingsFile) ? readJson(settingsFile) : {};
+  return syncUserSettingsShape(settings);
+}
+
+export function loadUserSettingsDocument(options = {}) {
+  return readRawUserSettingsDocument(options);
+}
+
 export function loadUserSettings(options = {}) {
   const settings = loadUserSettingsDocument(options);
   return {

package/src/execution_interactivity.mjs

@@ -0,0 +1,12 @@
+export function shouldPromptForEngineSelection(options = {}) {
+  if (options.yes) {
+    return false;
+  }
+  if (options.detach) {
+    return false;
+  }
+  if (process.env.HELLOLOOP_SUPERVISOR_ACTIVE === "1") {
+    return false;
+  }
+  return Boolean(process.stdout?.isTTY);
+}