dsh-autorestart 0.6.1 → 0.7.0

package/lib/diagnostics.js

@@ -0,0 +1,180 @@
+/**
+ * dsh-autorestart — THE DIAGNOSTICS BEHIND "REPORT A PROBLEM".
+ *
+ * When something goes wrong, the user should be able to hand us the facts in
+ * one click — without writing anything down by hand and without leaking
+ * anything private.
+ *
+ * There is exactly ONE generator (`buildDiagnostics`): the host builds the
+ * text, the browser copies it. Two generators would drift, and a drifted
+ * diagnostic is worse than none.
+ *
+ * WHAT IS IN IT: the plugin version, the platform, whether this is the
+ * desktop client, how the host was started (the mode AND the evidence the
+ * verdict rests on), who supervises it, the restart mode, and the verdict of
+ * the last restart (with the checks that failed).
+ *
+ * WHAT IS NEVER IN IT: the access token, a URL that carries a token, or any
+ * secret. The generator only copies the fields it knows, so a token cannot
+ * leak through a field nobody thought about — and everything that IS copied
+ * goes through the redaction again.
+ *
+ * ESM only, Node builtins only.
+ */
+
+/** The mailbox that works when GitHub does not. */
+export const SUPPORT_EMAIL = '252170229@qq.com'
+
+/** Where the "new issue" page lives. */
+export const ISSUE_URL_BASE = 'https://github.com/Eason-22/dsh-autorestart/issues/new'
+
+/** The body of a pre-filled issue must stay short: URLs have a length limit. */
+export const DIAGNOSTIC_BODY_LIMIT = 800
+
+/**
+ * The patterns that must never survive into a diagnostic.
+ *
+ * They cover the access token of the instance, the query parameters that
+ * carry it, and the usual "key: value" secrets.
+ */
+const SECRET_PATTERNS = Object.freeze([
+  /([?&](?:token|access[_-]?token|api[_-]?key|apikey|secret|password|auth|authorization)=)[^&\s"'<>]+/gi,
+  /("|')?(?:token|access[_-]?token|api[_-]?key|apikey|secret|password|authorization)("|')?\s*[:=]\s*(?:"[^"]*"|'[^']*'|[^\s,;}\]]+)/gi,
+  /\bBearer\s+[A-Za-z0-9._~+/-]{8,}=*/gi,
+])
+
+/**
+ * Remove anything that looks like a secret from a piece of text.
+ *
+ * @param {unknown} value
+ * @returns {string}
+ */
+export function redactSecrets(value) {
+  let text = typeof value === 'string' ? value : String(value ?? '')
+  for (const pattern of SECRET_PATTERNS) {
+    text = text.replace(pattern, '[redacted]')
+  }
+  return text
+}
+
+/**
+ * Shorten a path: the last four segments are kept (the user name may stay),
+ * everything before them is cut.
+ *
+ * @param {unknown} value
+ * @returns {string}
+ */
+export function truncatePath(value) {
+  const text = typeof value === 'string' ? value.trim() : ''
+  if (text === '') return ''
+  const parts = text.split(/[\\/]+/).filter((part) => part !== '')
+  if (parts.length <= 4) return text
+  return '…/' + parts.slice(-4).join('/')
+}
+
+/**
+ * Cut a text to a length limit (the issue body has to stay short).
+ *
+ * @param {string} text
+ * @param {number} [limit]
+ * @returns {string}
+ */
+export function truncateBody(text, limit = DIAGNOSTIC_BODY_LIMIT) {
+  const source = typeof text === 'string' ? text : ''
+  const max = Number.isFinite(Number(limit)) && Number(limit) > 0 ? Math.trunc(Number(limit)) : DIAGNOSTIC_BODY_LIMIT
+  if (source.length <= max) return source
+  return source.slice(0, Math.max(0, max - 1)) + '…'
+}
+
+/**
+ * The pre-filled "new issue" URL.
+ *
+ * @param {string} base
+ * @param {string} title
+ * @param {string} body
+ * @returns {string}
+ */
+export function buildIssueUrl(base, title, body) {
+  const root = typeof base === 'string' && base.trim() !== '' ? base.trim() : ISSUE_URL_BASE
+  const safeTitle = truncateBody(redactSecrets(title), 200)
+  const safeBody = truncateBody(redactSecrets(body), DIAGNOSTIC_BODY_LIMIT)
+  return root + '?title=' + encodeURIComponent(safeTitle) + '&body=' + encodeURIComponent(safeBody)
+}
+
+/**
+ * The `mailto:` link (the fallback when there is no GitHub account).
+ *
+ * @param {string} email
+ * @param {string} subject
+ * @param {string} body
+ * @returns {string}
+ */
+export function buildMailtoUrl(email, subject, body) {
+  const to = typeof email === 'string' && email.trim() !== '' ? email.trim() : SUPPORT_EMAIL
+  const safeSubject = truncateBody(redactSecrets(subject), 200)
+  const safeBody = truncateBody(redactSecrets(body), DIAGNOSTIC_BODY_LIMIT)
+  return 'mailto:' + to + '?subject=' + encodeURIComponent(safeSubject) + '&body=' + encodeURIComponent(safeBody)
+}
+
+/**
+ * Read one field out of a payload, without ever throwing.
+ *
+ * @param {any} source
+ * @param {string} key
+ * @param {any} [fallback]
+ * @returns {any}
+ */
+function field(source, key, fallback = '') {
+  if (!source || typeof source !== 'object') return fallback
+  const value = source[key]
+  return value === undefined || value === null ? fallback : value
+}
+
+/**
+ * The diagnostic text of this host.
+ *
+ * It is a PURE function of the payload: the same facts always produce the
+ * same text, and nothing outside the fields listed below can ever end up in
+ * it.
+ *
+ * @param {{
+ *   version?: string,
+ *   platform?: string,
+ *   hostKind?: string,
+ *   isDesktopApp?: boolean,
+ *   startup?: { mode?: string, kind?: string, evidence?: string },
+ *   supervisor?: { mode?: string, kind?: string },
+ *   restartMode?: string,
+ *   lastRestart?: { result?: string, failedChecks?: string[] },
+ *   stateDir?: string,
+ * }} [payload]
+ * @returns {string}
+ */
+export function buildDiagnostics(payload = {}) {
+  const source = payload && typeof payload === 'object' ? payload : {}
+  const startup = field(source, 'startup', {})
+  const supervisor = field(source, 'supervisor', {})
+  const lastRestart = field(source, 'lastRestart', {})
+  const failedChecks = Array.isArray(field(lastRestart, 'failedChecks', []))
+    ? field(lastRestart, 'failedChecks', []).map((check) => redactSecrets(String(check)))
+    : []
+
+  const lines = [
+    '--- dsh-autorestart diagnostics ---',
+    'plugin version: ' + redactSecrets(field(source, 'version', 'unknown')),
+    'platform: ' + redactSecrets(field(source, 'platform', 'unknown')),
+    'host kind: ' + redactSecrets(field(source, 'hostKind', 'unknown')),
+    'desktop client: ' + (field(source, 'isDesktopApp', false) === true ? 'yes' : 'no'),
+    'startup mode: ' + redactSecrets(field(startup, 'mode', 'unknown')),
+    'startup evidence: ' + redactSecrets(field(startup, 'evidence', 'unknown')),
+    'supervisor mode: ' + redactSecrets(field(supervisor, 'mode', 'unknown')),
+    'supervisor kind: ' + redactSecrets(field(supervisor, 'kind', 'unknown')),
+    'restart mode: ' + redactSecrets(field(source, 'restartMode', 'unknown')),
+    'last restart result: ' + redactSecrets(field(lastRestart, 'result', 'unknown')),
+    'last restart failed checks: ' + (failedChecks.length > 0 ? failedChecks.join(', ') : 'none'),
+  ]
+  const stateDir = truncatePath(field(source, 'stateDir', ''))
+  if (stateDir !== '') lines.push('dsh home: ' + redactSecrets(stateDir))
+  lines.push('--- end ---')
+  return lines.join('\n')
+}

package/lib/health.js

@@ -0,0 +1,264 @@
+/**
+ * dsh-autorestart — "is the new host really up?".
+ *
+ * A restart is only successful when the NEW instance answers its health route.
+ * The old instance's answer proves nothing: the old instance may still be
+ * running (the restart command did nothing), or it may answer on a port the
+ * new instance does not use (the desktop app listens on a random port).
+ *
+ * So the confirmation is built from two facts:
+ *
+ *   1. the INSTANCE RECORD (lib/access.js) of the new instance — it carries a
+ *      boot id that is different from the one of the instance that is being
+ *      replaced, and the port the new instance really listens on;
+ *   2. the health route of THAT port.
+ *
+ * The wait is bounded: when the new instance does not answer in time the
+ * caller gets a REASON, never a silent success.
+ *
+ * ESM only, Node builtins only. No DSH / npm imports.
+ */
+
+import http from 'node:http';
+import { URL } from 'node:url';
+
+import { readAccessRecordFile } from './access.js';
+
+/** How long one health request may take before it counts as "no answer". */
+export const DEFAULT_HEALTH_TIMEOUT_MS = 5000;
+
+/** How long the new instance may take to come up at all. */
+export const DEFAULT_INSTANCE_WAIT_MS = 90000;
+
+/** How often the instance record is read while waiting. */
+export const DEFAULT_INSTANCE_POLL_MS = 1000;
+
+/** @param {unknown} value */
+function errorText(value) {
+  if (value && typeof value.message === 'string' && value.message) return value.message;
+  return String(value);
+}
+
+/**
+ * Sleep for a while. Never rejects.
+ *
+ * @param {number} ms
+ * @returns {Promise<void>}
+ */
+function sleep(ms) {
+  return new Promise((resolve) => {
+    const timer = setTimeout(resolve, Math.max(0, Number(ms) || 0));
+    if (typeof timer.unref === 'function') timer.unref();
+  });
+}
+
+/**
+ * One plain HTTP GET, answered with the parsed JSON body.
+ *
+ * @param {string} url
+ * @param {number} timeoutMs
+ * @returns {Promise<{ ok: boolean, status: number, body: any, error: string|null }>}
+ */
+function httpGetJson(url, timeoutMs) {
+  return new Promise((resolve) => {
+    let settled = false;
+    const finish = (result) => {
+      if (settled) return;
+      settled = true;
+      resolve(result);
+    };
+    let request;
+    try {
+      request = http.get(url, { timeout: timeoutMs }, (response) => {
+        const chunks = [];
+        response.on('data', (chunk) => chunks.push(chunk));
+        response.on('end', () => {
+          const text = Buffer.concat(chunks).toString('utf8');
+          let body = null;
+          try {
+            body = JSON.parse(text);
+          } catch {
+            body = null;
+          }
+          const status = Number(response.statusCode) || 0;
+          finish({
+            ok: status >= 200 && status < 300 && body !== null && body.ok === true,
+            status,
+            body,
+            error: status >= 200 && status < 300
+              ? (body !== null && body.ok === true ? null : 'the health route did not answer ok')
+              : 'the health route answered with status ' + status,
+          });
+        });
+        response.on('error', (error) => {
+          finish({ ok: false, status: 0, body: null, error: errorText(error) });
+        });
+      });
+    } catch (error) {
+      finish({ ok: false, status: 0, body: null, error: errorText(error) });
+      return;
+    }
+    request.on('timeout', () => {
+      try {
+        request.destroy();
+      } catch {
+        /* nothing else to do */
+      }
+      finish({ ok: false, status: 0, body: null, error: 'the health request timed out' });
+    });
+    request.on('error', (error) => {
+      finish({ ok: false, status: 0, body: null, error: errorText(error) });
+    });
+  });
+}
+
+/**
+ * Ask one health route whether the host behind it is alive.
+ *
+ * @param {{ url?: string, timeoutMs?: number, requestImpl?: Function }} [options]
+ * @returns {Promise<{ ok: boolean, status: number, error: string|null }>}
+ */
+export function probeHealth({ url = '', timeoutMs = DEFAULT_HEALTH_TIMEOUT_MS, requestImpl = null } = {}) {
+  const target = typeof url === 'string' ? url.trim() : '';
+  if (target === '') {
+    return Promise.resolve({ ok: false, status: 0, error: 'probeHealth requires a url' });
+  }
+  const budget = Number.isFinite(Number(timeoutMs)) && Number(timeoutMs) > 0
+    ? Math.trunc(Number(timeoutMs))
+    : DEFAULT_HEALTH_TIMEOUT_MS;
+  const request = typeof requestImpl === 'function' ? requestImpl : httpGetJson;
+  return new Promise((resolve) => {
+    let settled = false;
+    const finish = (result) => {
+      if (settled) return;
+      settled = true;
+      resolve(result);
+    };
+    const timer = setTimeout(() => {
+      finish({ ok: false, status: 0, error: 'the health request timed out after ' + budget + 'ms' });
+    }, budget);
+    Promise.resolve()
+      .then(() => request(target, budget))
+      .then((response) => {
+        clearTimeout(timer);
+        const status = Number(response && response.status) || 0;
+        if (response && response.ok === true) {
+          finish({ ok: true, status: status || 200, error: null });
+          return;
+        }
+        finish({
+          ok: false,
+          status,
+          error: (response && response.error) || 'the health route did not answer ok',
+        });
+      })
+      .catch((error) => {
+        clearTimeout(timer);
+        finish({ ok: false, status: 0, error: errorText(error) });
+      });
+  });
+}
+
+/**
+ * The health URL of one port on the loopback interface.
+ *
+ * @param {number|string} port
+ * @param {string} healthPath
+ * @returns {string}
+ */
+export function healthUrlForPort(port, healthPath) {
+  const number = Number(port);
+  if (!Number.isFinite(number) || number <= 0) return '';
+  const path = typeof healthPath === 'string' && healthPath.startsWith('/')
+    ? healthPath
+    : '/__dsh_autorestart/health';
+  return 'http://127.0.0.1:' + Math.trunc(number) + path;
+}
+
+/**
+ * Wait until the instance that replaced `expectedBootId` answers its health
+ * route.
+ *
+ * The instance record is the only source of the new port: the desktop app
+ * listens on a random port, so the port of the old instance is meaningless.
+ *
+ * @param {{
+ *   accessFile?: string,
+ *   expectedBootId?: string|null,
+ *   healthPath?: string,
+ *   timeoutMs?: number,
+ *   intervalMs?: number,
+ *   probe?: Function,
+ *   readRecord?: Function,
+ *   now?: Function,
+ *   sleep?: Function,
+ * }} [options]
+ * @returns {Promise<{ ok: boolean, bootId: string|null, port: number|null, url: string|null, reason: string }>}
+ */
+export async function waitForHealthyInstance({
+  accessFile = '',
+  expectedBootId = null,
+  healthPath = '/__dsh_autorestart/health',
+  timeoutMs = DEFAULT_INSTANCE_WAIT_MS,
+  intervalMs = DEFAULT_INSTANCE_POLL_MS,
+  probe = probeHealth,
+  readRecord = readAccessRecordFile,
+  now = () => Date.now(),
+  sleep: sleepFn = sleep,
+} = {}) {
+  const file = typeof accessFile === 'string' ? accessFile.trim() : '';
+  const budget = Number.isFinite(Number(timeoutMs)) && Number(timeoutMs) > 0
+    ? Math.trunc(Number(timeoutMs))
+    : DEFAULT_INSTANCE_WAIT_MS;
+  const step = Number.isFinite(Number(intervalMs)) && Number(intervalMs) > 0
+    ? Math.trunc(Number(intervalMs))
+    : DEFAULT_INSTANCE_POLL_MS;
+  const expected = typeof expectedBootId === 'string' && expectedBootId !== '' ? expectedBootId : null;
+  const deadline = now() + budget;
+  let lastReason = 'the new instance did not come up in time';
+
+  if (file === '') {
+    return { ok: false, bootId: null, port: null, url: null, reason: 'waitForHealthyInstance requires the instance record' };
+  }
+
+  while (now() < deadline) {
+    const read = readRecord(file);
+    const record = read && read.ok === true ? read.record : null;
+    const bootId = record && typeof record.bootId === 'string' ? record.bootId : null;
+    const port = record && Number.isFinite(Number(record.port)) ? Number(record.port) : null;
+    const isNewInstance = bootId !== null && (expected === null || bootId !== expected);
+    if (isNewInstance && port !== null && port > 0) {
+      const url = healthUrlForPort(port, healthPath);
+      const answer = await probe({ url, timeoutMs: DEFAULT_HEALTH_TIMEOUT_MS });
+      if (answer && answer.ok === true) {
+        return { ok: true, bootId, port, url, reason: 'the new instance answered its health route' };
+      }
+      lastReason = (answer && answer.error) || 'the new instance did not answer its health route';
+    } else if (record === null) {
+      lastReason = 'the instance record is not readable yet';
+    } else if (!isNewInstance) {
+      lastReason = 'the instance that answers is still the one that is being replaced';
+    } else {
+      lastReason = 'the new instance did not publish its port yet';
+    }
+    await sleepFn(step);
+  }
+  return { ok: false, bootId: null, port: null, url: null, reason: lastReason };
+}
+
+/**
+ * The token of an access URL, or null.
+ *
+ * @param {string} url
+ * @returns {string|null}
+ */
+export function tokenOf(url) {
+  const text = typeof url === 'string' ? url.trim() : '';
+  if (text === '') return null;
+  try {
+    const parsed = new URL(text);
+    return parsed.searchParams.get('token');
+  } catch {
+    return null;
+  }
+}

package/lib/host-kind.js

@@ -0,0 +1,145 @@
+/**
+ * dsh-autorestart — WHICH MACHINE IS THIS?
+ *
+ * The plugin has to know whether it runs on Windows, on a real Linux, on a
+ * macOS or INSIDE WSL (the Linux of Windows). The answer changes what may be
+ * done:
+ *
+ *   - the graceful shutdown must reach the PHYSICAL machine (in WSL, shutting
+ *     the distro down only stops the subsystem);
+ *   - the "start at login" of the supervisor is a different thing in WSL
+ *     (a systemd user unit + `loginctl enable-linger`, or a Windows-side
+ *     task) than on a real Linux;
+ *   - inside WSL there is NO Docker/Compose answer: the orchestrator is
+ *     Windows itself.
+ *
+ * So the detection lives HERE, once, and both halves of the plugin use it.
+ *
+ * Everything is dependency-injected (the platform, the environment, the file
+ * probes), so the whole matrix can be tested without a machine.
+ *
+ * ESM only, Node builtins only.
+ */
+
+import fs from 'node:fs'
+
+/** The Windows shutdown binary as it is reachable from WSL. */
+export const WSL_SHUTDOWN_EXE = '/mnt/c/Windows/System32/shutdown.exe'
+
+/** The file that tells a WSL kernel from a real Linux kernel. */
+export const WSL_PROC_VERSION = '/proc/version'
+
+/** The kinds of host the plugin knows. */
+export const HOST_KINDS = Object.freeze({
+  WINDOWS: 'windows',
+  WSL: 'wsl',
+  LINUX: 'linux',
+  MACOS: 'macos',
+  UNSUPPORTED: 'unsupported',
+})
+
+/** @param {unknown} value */
+function nonEmptyString(value) {
+  return typeof value === 'string' && value.trim() !== '' ? value.trim() : ''
+}
+
+/**
+ * The evidence that this Linux is really a WSL distribution.
+ *
+ * Any ONE of them is enough:
+ *   1. `WSL_DISTRO_NAME` is set (WSL exports it into every process),
+ *   2. `WSL_INTEROP` is set (WSL exports it into every process),
+ *   3. `/proc/version` mentions "microsoft" (the WSL kernel says so),
+ *   4. the Windows shutdown binary is reachable under `/mnt/c`.
+ *
+ * @param {object} env
+ * @param {(file: string) => string} readFile
+ * @param {(file: string) => boolean} exists
+ * @returns {string|null} the name of the evidence, or null
+ */
+export function detectWslEvidence(env, readFile, exists) {
+  const environ = env && typeof env === 'object' ? env : {}
+  if (nonEmptyString(environ.WSL_DISTRO_NAME) !== '') return 'WSL_DISTRO_NAME'
+  if (nonEmptyString(environ.WSL_INTEROP) !== '') return 'WSL_INTEROP'
+  let version = ''
+  try {
+    version = String(readFile(WSL_PROC_VERSION) || '')
+  } catch {
+    version = ''
+  }
+  if (version.toLowerCase().includes('microsoft')) return WSL_PROC_VERSION
+  let found = false
+  try {
+    found = exists(WSL_SHUTDOWN_EXE) === true
+  } catch {
+    found = false
+  }
+  if (found) return WSL_SHUTDOWN_EXE
+  return null
+}
+
+/**
+ * Which machine is this?
+ *
+ * `suspect` is true when the ONLY evidence is the mounted Windows drive: a
+ * real Linux with a manually mounted C: drive looks exactly the same. The
+ * plugin says so instead of pretending to be sure — and it does NOT change
+ * any system configuration on such a guess.
+ *
+ * @param {{
+ *   platform?: string,
+ *   env?: object,
+ *   readFile?: (file: string) => string,
+ *   exists?: (file: string) => boolean,
+ * }} [options]
+ * @returns {{
+ *   kind: 'windows'|'wsl'|'linux'|'macos'|'unsupported',
+ *   platform: string,
+ *   evidence: string,
+ *   suspect: boolean,
+ *   distro: string,
+ * }}
+ */
+export function detectHostKind({
+  platform = process.platform,
+  env = process.env,
+  readFile,
+  exists,
+} = {}) {
+  const plat = nonEmptyString(platform) || process.platform
+  const environ = env && typeof env === 'object' ? env : process.env
+  const readFileSafe = typeof readFile === 'function'
+    ? readFile
+    : (file) => fs.readFileSync(file, 'utf8')
+  const existsSafe = typeof exists === 'function'
+    ? exists
+    : (file) => fs.existsSync(file)
+
+  const base = {
+    platform: plat,
+    evidence: 'process.platform',
+    suspect: false,
+    distro: nonEmptyString(environ.WSL_DISTRO_NAME),
+  }
+
+  if (plat === 'win32') {
+    return { ...base, kind: HOST_KINDS.WINDOWS }
+  }
+  if (plat === 'linux') {
+    const evidence = detectWslEvidence(environ, readFileSafe, existsSafe)
+    if (evidence !== null) {
+      return {
+        ...base,
+        kind: HOST_KINDS.WSL,
+        evidence,
+        // Only the mounted drive: that is a HINT, not a proof.
+        suspect: evidence === WSL_SHUTDOWN_EXE,
+      }
+    }
+    return { ...base, kind: HOST_KINDS.LINUX }
+  }
+  if (plat === 'darwin') {
+    return { ...base, kind: HOST_KINDS.MACOS }
+  }
+  return { ...base, kind: HOST_KINDS.UNSUPPORTED }
+}

package/lib/lifecycle.js

@@ -262,10 +262,12 @@ export function selectGoalDisarms(busyAgents, { getGoal, disarmedGoals, parkedGo
  *   forceRestartWhenBusy?: boolean,
  * }} [options]
  * @returns {{
- *   action: 'none'|'wait'|'warn'|'restart'|'force-restart'|'give-up',
+ *   action: 'none'|'wait'|'warn'|'long-wait'|'restart'|'force-restart'|'give-up',
  *   reason: string,
  *   log?: string,
  *   markSoftWarned?: boolean,
+ *   blockedBy?: { sessionId: string|null, reason: string }[],
+ *   waitingSince?: number,
  * }}
  */
 export function restartDecision(
@@ -325,11 +327,19 @@ export function restartDecision(
   }
 
   // Hard deadline reached while a conversation is still running.
+  //
+  // From here on the plugin does NOT pretend that "everything is fine, we are
+  // just waiting a little longer": the wait has become a LONG wait, and the
+  // caller (index.js) has to make it VISIBLE — in the log and in the state
+  // payload — while KEEPING the user's restart request alive. The request is
+  // never silently dropped.
   if (policy === 'wait') {
     return {
-      action: 'warn',
+      action: 'long-wait',
       reason: 'hard-deadline-policy-wait',
       log: 'defer policy wait: still busy after hard deadline',
+      blockedBy: busy,
+      waitingSince: requestedAt,
     };
   }
   // The hard deadline only forces a restart when the operator explicitly opted in
@@ -340,11 +350,14 @@ export function restartDecision(
     return { action: 'force-restart', reason: 'hard-deadline-force-restart' };
   }
   // forceRestartWhenBusy is disabled (the default): the restart keeps waiting
-  // until the idle gate is quiet again, and it never gives up.
+  // until the idle gate is quiet again, and it never gives up. The result says
+  // so explicitly — a long wait, with the sessions that hold it.
   return {
-    action: 'warn',
+    action: 'long-wait',
     reason: 'hard-deadline-waiting-for-conversations',
     log: 'dsh-autorestart: hard deadline reached but conversations are still running; forceRestartWhenBusy is disabled, so the restart keeps waiting',
+    blockedBy: busy,
+    waitingSince: requestedAt,
   };
 }