helloloop 0.8.5 → 0.9.1

package/src/supervisor_watch.mjs

@@ -0,0 +1,320 @@
+import fs from "node:fs";
+import path from "node:path";
+
+import { fileExists, readJson, sleep } from "./common.mjs";
+import { renderHostLeaseLabel } from "./host_lease.mjs";
+
+const FINAL_STATUSES = new Set(["completed", "failed", "stopped"]);
+
+function readJsonIfExists(filePath) {
+  if (!filePath || !fileExists(filePath)) {
+    return null;
+  }
+
+  try {
+    return readJson(filePath);
+  } catch {
+    return null;
+  }
+}
+
+function writeLine(stream, message) {
+  stream.write(`${message}\n`);
+}
+
+function buildSessionSummary(supervisor) {
+  if (!supervisor?.sessionId) {
+    return "";
+  }
+
+  return [
+    `[HelloLoop watch] 已附着后台会话：${supervisor.sessionId}`,
+    `[HelloLoop watch] 宿主租约：${renderHostLeaseLabel(supervisor.lease)}`,
+  ].join("\n");
+}
+
+function formatSupervisorState(supervisor) {
+  if (!supervisor?.status) {
+    return "";
+  }
+
+  const label = {
+    launching: "后台 supervisor 启动中",
+    running: "后台 supervisor 正在运行",
+    completed: "后台 supervisor 已完成",
+    failed: "后台 supervisor 执行失败",
+    stopped: "后台 supervisor 已停止",
+  }[String(supervisor.status)] || `后台 supervisor 状态：${supervisor.status}`;
+
+  const suffix = supervisor.message ? `：${supervisor.message}` : "";
+  return `[HelloLoop watch] ${label}${suffix}`;
+}
+
+function formatTaskStatus(status) {
+  if (!status?.taskTitle) {
+    return "";
+  }
+
+  const lines = [`[HelloLoop watch] 当前任务：${status.taskTitle}`];
+  if (status.runDir) {
+    lines.push(`[HelloLoop watch] 运行目录：${status.runDir}`);
+  }
+  if (status.stage) {
+    lines.push(`[HelloLoop watch] 阶段：${status.stage}`);
+  }
+  return lines.join("\n");
+}
+
+function selectRuntimeFile(runDir) {
+  if (!runDir || !fileExists(runDir)) {
+    return "";
+  }
+
+  const candidates = [];
+  for (const entry of fs.readdirSync(runDir, { withFileTypes: true })) {
+    if (entry.isFile() && entry.name.endsWith("-runtime.json")) {
+      candidates.push(path.join(runDir, entry.name));
+      continue;
+    }
+    if (!entry.isDirectory()) {
+      continue;
+    }
+    const nestedDir = path.join(runDir, entry.name);
+    for (const nestedName of fs.readdirSync(nestedDir)) {
+      if (nestedName.endsWith("-runtime.json")) {
+        candidates.push(path.join(nestedDir, nestedName));
+      }
+    }
+  }
+
+  candidates.sort((left, right) => {
+    const rightTime = fs.statSync(right).mtimeMs;
+    const leftTime = fs.statSync(left).mtimeMs;
+    return rightTime - leftTime;
+  });
+
+  return candidates[0] || "";
+}
+
+function formatRuntimeState(runtime, previousRuntime) {
+  if (!runtime?.status) {
+    return "";
+  }
+
+  const idleSeconds = Number(runtime?.heartbeat?.idleSeconds || 0);
+  const idleBucket = Math.floor(idleSeconds / 30);
+  const previousIdleBucket = Math.floor(Number(previousRuntime?.heartbeat?.idleSeconds || 0) / 30);
+  const signature = [
+    runtime.status,
+    runtime.attemptPrefix || "",
+    runtime.recoveryCount || 0,
+    runtime.failureCode || "",
+    runtime.failureReason || "",
+    runtime.nextRetryAt || "",
+    runtime.notification?.reason || "",
+  ].join("|");
+  const previousSignature = previousRuntime
+    ? [
+      previousRuntime.status,
+      previousRuntime.attemptPrefix || "",
+      previousRuntime.recoveryCount || 0,
+      previousRuntime.failureCode || "",
+      previousRuntime.failureReason || "",
+      previousRuntime.nextRetryAt || "",
+      previousRuntime.notification?.reason || "",
+    ].join("|")
+    : "";
+
+  if (signature === previousSignature && (runtime.status !== "running" || idleBucket === previousIdleBucket || idleBucket === 0)) {
+    return "";
+  }
+
+  if (runtime.status === "running") {
+    if (idleBucket === 0 || idleBucket === previousIdleBucket) {
+      return "";
+    }
+    return `[HelloLoop watch] 仍在执行：${runtime.attemptPrefix || "当前尝试"}，最近输出距今约 ${idleBucket * 30} 秒`;
+  }
+
+  const labels = {
+    recovering: "进入同引擎恢复",
+    suspected_stall: "疑似卡住，继续观察",
+    watchdog_terminating: "触发 watchdog，准备终止当前子进程",
+    watchdog_waiting: "watchdog 等待子进程退出",
+    retry_waiting: "等待自动重试",
+    probe_waiting: "准备执行健康探测",
+    probe_running: "正在执行健康探测",
+    paused_manual: "自动恢复预算已耗尽，任务暂停",
+    lease_terminating: "宿主租约失效，正在停止当前子进程",
+    stopped_host_closed: "宿主窗口已关闭，后台任务停止",
+    completed: "当前任务执行完成",
+    failed: "当前任务执行失败",
+  };
+  const label = labels[String(runtime.status)] || `运行状态更新：${runtime.status}`;
+  const details = [
+    runtime.attemptPrefix ? `attempt=${runtime.attemptPrefix}` : "",
+    Number.isFinite(Number(runtime.recoveryCount)) ? `recovery=${runtime.recoveryCount}` : "",
+    runtime.nextRetryAt ? `next=${runtime.nextRetryAt}` : "",
+    runtime.failureReason || "",
+  ].filter(Boolean).join(" | ");
+
+  return `[HelloLoop watch] ${label}${details ? ` | ${details}` : ""}`;
+}
+
+function readTextDelta(filePath, offset) {
+  if (!filePath || !fileExists(filePath)) {
+    return { nextOffset: 0, text: "" };
+  }
+
+  const stats = fs.statSync(filePath);
+  if (stats.size <= 0) {
+    return { nextOffset: 0, text: "" };
+  }
+
+  const start = Math.max(0, Math.min(Number(offset || 0), stats.size));
+  if (stats.size === start) {
+    return { nextOffset: start, text: "" };
+  }
+
+  const handle = fs.openSync(filePath, "r");
+  try {
+    const buffer = Buffer.alloc(stats.size - start);
+    fs.readSync(handle, buffer, 0, buffer.length, start);
+    return {
+      nextOffset: stats.size,
+      text: buffer.toString("utf8"),
+    };
+  } finally {
+    fs.closeSync(handle);
+  }
+}
+
+function readAndWriteDelta(cursor, filePath, stream) {
+  if (cursor.file !== filePath) {
+    cursor.file = filePath || "";
+    cursor.offset = 0;
+  }
+
+  if (!filePath) {
+    return;
+  }
+
+  const delta = readTextDelta(filePath, cursor.offset);
+  cursor.offset = delta.nextOffset;
+  if (!delta.text) {
+    return;
+  }
+
+  stream.write(delta.text);
+  if (!delta.text.endsWith("\n")) {
+    stream.write("\n");
+  }
+}
+
+function resolveStatusForSession(status, sessionId) {
+  if (!status) {
+    return null;
+  }
+  if (!sessionId || !status.sessionId || status.sessionId === sessionId) {
+    return status;
+  }
+  return null;
+}
+
+function buildWatchResult(supervisor, result) {
+  const exitCode = Number(result?.exitCode ?? supervisor?.exitCode ?? (supervisor?.status === "completed" ? 0 : 1));
+  return {
+    sessionId: result?.sessionId || supervisor?.sessionId || "",
+    status: result?.ok === true
+      ? "completed"
+      : (supervisor?.status || (exitCode === 0 ? "completed" : "failed")),
+    ok: result?.ok === true || exitCode === 0,
+    exitCode,
+  };
+}
+
+export async function watchSupervisorSession(context, options = {}) {
+  const pollMs = Math.max(200, Number(options.pollMs || 1000));
+  const stdoutStream = options.stdoutStream || process.stdout;
+  const stderrStream = options.stderrStream || process.stderr;
+  const expectedSessionId = String(options.sessionId || "").trim();
+  const stdoutCursor = { file: "", offset: 0 };
+  const stderrCursor = { file: "", offset: 0 };
+  let printedSessionId = "";
+  let lastSupervisorSignature = "";
+  let lastTaskSignature = "";
+  let previousRuntime = null;
+  let missingPolls = 0;
+
+  while (true) {
+    const supervisor = readJsonIfExists(context.supervisorStateFile);
+    const result = readJsonIfExists(context.supervisorResultFile);
+    const activeSessionId = expectedSessionId || supervisor?.sessionId || result?.sessionId || "";
+    const taskStatus = resolveStatusForSession(readJsonIfExists(context.statusFile), activeSessionId);
+    const runtimeFile = taskStatus?.runDir ? selectRuntimeFile(taskStatus.runDir) : "";
+    const runtime = readJsonIfExists(runtimeFile);
+
+    if (!supervisor && !result) {
+      missingPolls += 1;
+      if (missingPolls >= 3) {
+        return {
+          sessionId: activeSessionId,
+          status: "",
+          ok: false,
+          exitCode: 1,
+          empty: true,
+        };
+      }
+      await sleep(pollMs);
+      continue;
+    }
+    missingPolls = 0;
+
+    if (supervisor?.sessionId && supervisor.sessionId !== printedSessionId) {
+      printedSessionId = supervisor.sessionId;
+      writeLine(stdoutStream, buildSessionSummary(supervisor));
+    }
+
+    const supervisorSignature = supervisor
+      ? [supervisor.sessionId || "", supervisor.status || "", supervisor.message || ""].join("|")
+      : "";
+    if (supervisorSignature && supervisorSignature !== lastSupervisorSignature) {
+      lastSupervisorSignature = supervisorSignature;
+      writeLine(stdoutStream, formatSupervisorState(supervisor));
+    }
+
+    const taskSignature = taskStatus
+      ? [taskStatus.sessionId || "", taskStatus.taskId || "", taskStatus.taskTitle || "", taskStatus.runDir || "", taskStatus.stage || ""].join("|")
+      : "";
+    if (taskSignature && taskSignature !== lastTaskSignature) {
+      lastTaskSignature = taskSignature;
+      writeLine(stdoutStream, formatTaskStatus(taskStatus));
+    }
+
+    const runtimeMessage = formatRuntimeState(runtime, previousRuntime);
+    if (runtimeMessage) {
+      writeLine(stdoutStream, runtimeMessage);
+    }
+    previousRuntime = runtime || previousRuntime;
+
+    const activePrefix = runtime?.attemptPrefix || "";
+    const runtimeDir = runtimeFile ? path.dirname(runtimeFile) : "";
+    const stdoutFile = runtimeDir && activePrefix
+      ? path.join(runtimeDir, `${activePrefix}-stdout.log`)
+      : "";
+    const stderrFile = runtimeDir && activePrefix
+      ? path.join(runtimeDir, `${activePrefix}-stderr.log`)
+      : "";
+
+    readAndWriteDelta(stdoutCursor, stdoutFile, stdoutStream);
+    readAndWriteDelta(stderrCursor, stderrFile, stderrStream);
+
+    if (supervisor?.status && FINAL_STATUSES.has(String(supervisor.status))) {
+      readAndWriteDelta(stdoutCursor, stdoutFile, stdoutStream);
+      readAndWriteDelta(stderrCursor, stderrFile, stderrStream);
+      return buildWatchResult(supervisor, result);
+    }
+
+    await sleep(pollMs);
+  }
+}

package/src/terminal_session_limits.mjs

@@ -0,0 +1,394 @@
+import fs from "node:fs";
+import path from "node:path";
+
+import { ensureDir, fileExists, nowIso, readJson, timestampForFile, writeJson } from "./common.mjs";
+import { loadGlobalConfig } from "./global_config.mjs";
+
+const SESSION_DIR_NAME = "terminal-sessions";
+const RUNTIME_DIR_NAME = "runtime";
+const LOCK_FILE_NAME = ".lock";
+const LOCK_RETRY_DELAYS_MS = [0, 20, 50, 100, 200, 300, 500];
+const STALE_PREPARED_SESSION_MS = 60_000;
+const TRACKED_VISIBLE_COMMANDS = new Set(["analyze", "next", "run-loop", "run-once"]);
+
+let currentTerminalSession = null;
+let cleanupRegistered = false;
+
+function sleepSync(ms) {
+  const shared = new SharedArrayBuffer(4);
+  const view = new Int32Array(shared);
+  Atomics.wait(view, 0, 0, Math.max(0, ms));
+}
+
+function isPidAlive(pid) {
+  const value = Number(pid || 0);
+  if (!Number.isFinite(value) || value <= 0) {
+    return false;
+  }
+  try {
+    process.kill(value, 0);
+    return true;
+  } catch (error) {
+    return String(error?.code || "") === "EPERM";
+  }
+}
+
+function normalizeNonNegativeInteger(value, fallbackValue) {
+  if (value === null || value === undefined || value === "") {
+    return fallbackValue;
+  }
+  const parsed = Number(value);
+  if (!Number.isFinite(parsed) || parsed < 0) {
+    return fallbackValue;
+  }
+  return Math.floor(parsed);
+}
+
+export function normalizeTerminalConcurrencySettings(settings = {}) {
+  const source = settings && typeof settings === "object" ? settings : {};
+  return {
+    enabled: source.enabled !== false,
+    visibleMax: normalizeNonNegativeInteger(source.visibleMax, 8),
+    backgroundMax: normalizeNonNegativeInteger(source.backgroundMax, 8),
+    totalMax: normalizeNonNegativeInteger(source.totalMax, 8),
+  };
+}
+
+function resolveTerminalRuntimeConfig(options = {}) {
+  const globalConfig = loadGlobalConfig({
+    globalConfigFile: options.globalConfigFile,
+  });
+  const settingsFile = globalConfig?._meta?.configFile || "";
+  const settingsHome = settingsFile ? path.dirname(settingsFile) : process.cwd();
+  return {
+    settingsFile,
+    registryRoot: path.join(settingsHome, RUNTIME_DIR_NAME, SESSION_DIR_NAME),
+    limits: normalizeTerminalConcurrencySettings(globalConfig?.runtime?.terminalConcurrency || {}),
+  };
+}
+
+function withRegistryLock(registryRoot, callback) {
+  ensureDir(registryRoot);
+  const lockFile = path.join(registryRoot, LOCK_FILE_NAME);
+  let lastError = null;
+
+  for (const delayMs of LOCK_RETRY_DELAYS_MS) {
+    if (delayMs > 0) {
+      sleepSync(delayMs);
+    }
+    let lockFd = null;
+    try {
+      lockFd = fs.openSync(lockFile, "wx");
+      const result = callback();
+      fs.closeSync(lockFd);
+      fs.rmSync(lockFile, { force: true });
+      return result;
+    } catch (error) {
+      lastError = error;
+      if (lockFd !== null) {
+        try {
+          fs.closeSync(lockFd);
+        } catch {
+          // ignore lock close failure
+        }
+        fs.rmSync(lockFile, { force: true });
+        throw error;
+      }
+      if (String(error?.code || "").toUpperCase() !== "EEXIST") {
+        throw error;
+      }
+    }
+  }
+
+  throw lastError || new Error(`无法获取 HelloLoop 终端会话锁：${registryRoot}`);
+}
+
+function listSessionFiles(registryRoot) {
+  if (!fileExists(registryRoot)) {
+    return [];
+  }
+  return fs.readdirSync(registryRoot)
+    .filter((item) => item.endsWith(".json"))
+    .map((item) => path.join(registryRoot, item));
+}
+
+function readSessionRecord(sessionFile) {
+  try {
+    return readJson(sessionFile);
+  } catch {
+    return null;
+  }
+}
+
+function isPreparedSessionExpired(record) {
+  const updatedAt = Date.parse(String(record?.updatedAt || record?.createdAt || ""));
+  if (!Number.isFinite(updatedAt)) {
+    return true;
+  }
+  return Date.now() - updatedAt > STALE_PREPARED_SESSION_MS;
+}
+
+function isStaleSession(record) {
+  const kind = String(record?.kind || "");
+  if (!["visible", "background"].includes(kind)) {
+    return true;
+  }
+  if (Number(record?.pid || 0) > 0) {
+    return !isPidAlive(record.pid);
+  }
+  if (Number(record?.ownerPid || 0) > 0 && !isPidAlive(record.ownerPid)) {
+    return true;
+  }
+  return isPreparedSessionExpired(record);
+}
+
+function cleanupStaleSessions(registryRoot) {
+  const activeSessions = [];
+  for (const sessionFile of listSessionFiles(registryRoot)) {
+    const record = readSessionRecord(sessionFile);
+    if (!record || isStaleSession(record)) {
+      fs.rmSync(sessionFile, { force: true });
+      continue;
+    }
+    activeSessions.push({
+      ...record,
+      file: sessionFile,
+    });
+  }
+  return activeSessions;
+}
+
+function countSessions(sessions, excludingId = "") {
+  return sessions
+    .filter((session) => session.id !== excludingId)
+    .reduce((counts, session) => {
+      if (session.kind === "visible") {
+        counts.visible += 1;
+      }
+      if (session.kind === "background") {
+        counts.background += 1;
+      }
+      counts.total += 1;
+      return counts;
+    }, { visible: 0, background: 0, total: 0 });
+}
+
+function throwSessionLimitError(kind, counts, limits, settingsFile, reason) {
+  const kindLabel = kind === "background" ? "背景终端" : "显示终端";
+  const scope = [
+    `显示终端 ${counts.visible}/${limits.visibleMax}`,
+    `背景终端 ${counts.background}/${limits.backgroundMax}`,
+    `总并发 ${counts.total}/${limits.totalMax}`,
+  ].join("，");
+  throw new Error(
+    `${kindLabel}${reason}，当前 ${scope}。`
+    + ` 如需调整，请修改 ${settingsFile} 中的 runtime.terminalConcurrency.visibleMax / backgroundMax / totalMax。`,
+  );
+}
+
+function assertSessionLimit(kind, sessions, limits, settingsFile, excludingId = "") {
+  if (!limits.enabled) {
+    return;
+  }
+
+  const counts = countSessions(sessions, excludingId);
+  const nextCounts = {
+    visible: counts.visible + (kind === "visible" ? 1 : 0),
+    background: counts.background + (kind === "background" ? 1 : 0),
+    total: counts.total + 1,
+  };
+
+  if (kind === "visible" && nextCounts.visible > limits.visibleMax) {
+    throwSessionLimitError(kind, nextCounts, limits, settingsFile, "并发已达上限");
+  }
+  if (kind === "background" && nextCounts.background > limits.backgroundMax) {
+    throwSessionLimitError(kind, nextCounts, limits, settingsFile, "并发已达上限");
+  }
+  if (nextCounts.total > limits.totalMax) {
+    throwSessionLimitError(kind, nextCounts, limits, settingsFile, "启动被阻止：显示终端与背景终端合计并发已达上限");
+  }
+}
+
+function buildSessionRecord(kind, options = {}) {
+  return {
+    id: options.id || `${timestampForFile()}-${kind}-${process.pid}`,
+    kind,
+    pid: Number(options.pid || process.pid),
+    ownerPid: Number(options.ownerPid || process.pid),
+    command: String(options.command || "").trim(),
+    sessionId: String(options.sessionId || "").trim(),
+    repoRoot: String(options.repoRoot || "").trim(),
+    createdAt: options.createdAt || nowIso(),
+    updatedAt: nowIso(),
+  };
+}
+
+function writeSessionRecord(sessionFile, record) {
+  writeJson(sessionFile, record);
+  return {
+    ...record,
+    file: sessionFile,
+  };
+}
+
+function ensureCleanupRegistration() {
+  if (cleanupRegistered) {
+    return;
+  }
+  cleanupRegistered = true;
+  process.on("exit", () => {
+    try {
+      releaseCurrentTerminalSession();
+    } catch {
+      // ignore exit cleanup failure
+    }
+  });
+}
+
+function setCurrentTerminalSession(record) {
+  if (!record) {
+    return null;
+  }
+  currentTerminalSession = {
+    ...record,
+    preparedForBackground: false,
+    handedOff: false,
+  };
+  ensureCleanupRegistration();
+  return currentTerminalSession;
+}
+
+export function shouldTrackVisibleTerminalCommand(command) {
+  return TRACKED_VISIBLE_COMMANDS.has(String(command || "").trim());
+}
+
+export function acquireVisibleTerminalSession(options = {}) {
+  if (currentTerminalSession) {
+    return currentTerminalSession;
+  }
+
+  const runtime = resolveTerminalRuntimeConfig(options);
+  if (!runtime.limits.enabled) {
+    return null;
+  }
+
+  return withRegistryLock(runtime.registryRoot, () => {
+    const sessions = cleanupStaleSessions(runtime.registryRoot);
+    assertSessionLimit("visible", sessions, runtime.limits, runtime.settingsFile);
+    const record = buildSessionRecord("visible", options);
+    const sessionFile = path.join(runtime.registryRoot, `${record.id}.json`);
+    return setCurrentTerminalSession(writeSessionRecord(sessionFile, record));
+  });
+}
+
+export function prepareCurrentTerminalSessionForBackground(options = {}) {
+  const runtime = resolveTerminalRuntimeConfig(options);
+  if (!runtime.limits.enabled) {
+    return null;
+  }
+
+  return withRegistryLock(runtime.registryRoot, () => {
+    const sessions = cleanupStaleSessions(runtime.registryRoot);
+
+    if (!currentTerminalSession) {
+      assertSessionLimit("background", sessions, runtime.limits, runtime.settingsFile);
+      const record = buildSessionRecord("background", {
+        ...options,
+        pid: 0,
+      });
+      const sessionFile = path.join(runtime.registryRoot, `${record.id}.json`);
+      const next = writeSessionRecord(sessionFile, record);
+      currentTerminalSession = {
+        ...next,
+        preparedForBackground: true,
+        handedOff: false,
+      };
+      ensureCleanupRegistration();
+      return currentTerminalSession;
+    }
+
+    assertSessionLimit("background", sessions, runtime.limits, runtime.settingsFile, currentTerminalSession.id);
+    const record = buildSessionRecord("background", {
+      ...currentTerminalSession,
+      ...options,
+      pid: 0,
+      ownerPid: process.pid,
+    });
+    const next = writeSessionRecord(currentTerminalSession.file, record);
+    currentTerminalSession = {
+      ...next,
+      preparedForBackground: true,
+      handedOff: false,
+    };
+    return currentTerminalSession;
+  });
+}
+
+export function finalizePreparedTerminalSessionBackground(pid, options = {}) {
+  if (!currentTerminalSession?.file) {
+    return null;
+  }
+
+  const runtime = resolveTerminalRuntimeConfig(options);
+  return withRegistryLock(runtime.registryRoot, () => {
+    const record = buildSessionRecord("background", {
+      ...currentTerminalSession,
+      ...options,
+      pid,
+      ownerPid: pid,
+      createdAt: currentTerminalSession.createdAt,
+    });
+    const next = writeSessionRecord(currentTerminalSession.file, record);
+    currentTerminalSession = {
+      ...next,
+      preparedForBackground: false,
+      handedOff: true,
+    };
+    return currentTerminalSession;
+  });
+}
+
+export function cancelPreparedTerminalSessionBackground(options = {}) {
+  if (!currentTerminalSession?.file || !currentTerminalSession.preparedForBackground) {
+    return false;
+  }
+
+  const runtime = resolveTerminalRuntimeConfig(options);
+  return withRegistryLock(runtime.registryRoot, () => {
+    fs.rmSync(currentTerminalSession.file, { force: true });
+    currentTerminalSession = null;
+    return true;
+  });
+}
+
+export function bindBackgroundTerminalSession(sessionFile, options = {}) {
+  if (!sessionFile) {
+    return null;
+  }
+
+  const registryRoot = path.dirname(sessionFile);
+  return withRegistryLock(registryRoot, () => {
+    const existing = fileExists(sessionFile) ? readSessionRecord(sessionFile) : null;
+    const record = buildSessionRecord("background", {
+      ...existing,
+      ...options,
+      pid: process.pid,
+      ownerPid: process.pid,
+    });
+    return setCurrentTerminalSession(writeSessionRecord(sessionFile, record));
+  });
+}
+
+export function releaseCurrentTerminalSession() {
+  if (!currentTerminalSession?.file || currentTerminalSession.handedOff) {
+    return false;
+  }
+
+  const sessionFile = currentTerminalSession.file;
+  const registryRoot = path.dirname(sessionFile);
+  withRegistryLock(registryRoot, () => {
+    fs.rmSync(sessionFile, { force: true });
+  });
+  currentTerminalSession = null;
+  return true;
+}