@hivefloor/cli 0.0.0-stage → 0.1.0

package/dist/run-64ZYCJU2.js

@@ -0,0 +1,629 @@
+#!/usr/bin/env node
+import {
+  releaseSpool,
+  takeSpool
+} from "./chunk-SGDM7MAT.js";
+import {
+  buildProfiles,
+  cliVersionOs,
+  scanProcesses
+} from "./chunk-6UZBZ7LR.js";
+import {
+  claudeDirsFromRc,
+  profileKeyOf,
+  profileKeys,
+  uniqueProfileKey
+} from "./chunk-M3PLXINO.js";
+import {
+  readMachine,
+  writeMachine,
+  writeServiceState
+} from "./chunk-3IMV5EHP.js";
+import {
+  VERSION
+} from "./chunk-IEYWMDXA.js";
+import {
+  apiRequest
+} from "./chunk-PY74LT2W.js";
+import {
+  configDir,
+  home,
+  isRecord,
+  machineSpoolFile,
+  serviceLogFile
+} from "./chunk-WNDUGQDX.js";
+import {
+  HOOK_BATCH_MAX,
+  MACHINE_HEARTBEAT_SECONDS,
+  MACHINE_MIN_INTERVAL_SECONDS,
+  machineHeartbeatResponseSchema,
+  parseUsageKey,
+  runCmd
+} from "./chunk-RE2EQZWL.js";
+import "./chunk-K3NQKI34.js";
+
+// src/service/run.ts
+import fs2 from "fs";
+
+// src/service/collectors.ts
+import fs from "fs";
+import os from "os";
+import path from "path";
+var USAGE_WINDOW_MS = 24 * 60 * 60 * 1e3;
+var USAGE_MAX_FILES = 200;
+var USAGE_MAX_KEYS = 64;
+var CHUNK_BYTES = 64 * 1024;
+var MAX_LINE_BYTES = 2 * 1024 * 1024;
+var MAX_SEEN_IDS = 1e4;
+var SESSION_ID_RE = /^[A-Za-z0-9._:-]{1,60}$/;
+function asNonNegInt(v) {
+  if (typeof v !== "number" || !Number.isFinite(v) || v < 0) return void 0;
+  return Math.floor(v);
+}
+function asPositiveCost(v) {
+  if (typeof v !== "number" || !Number.isFinite(v) || v <= 0) return void 0;
+  return v;
+}
+function asShortId(v) {
+  return typeof v === "string" && v.length > 0 && v.length <= 120 ? v : void 0;
+}
+function isDir(p) {
+  try {
+    return fs.statSync(p).isDirectory();
+  } catch {
+    return false;
+  }
+}
+function claudeProfileDirs(env, homeDir) {
+  const std = path.resolve(path.join(homeDir, ".claude"));
+  const raw = [std];
+  if (env.CLAUDE_CONFIG_DIR) raw.push(path.resolve(env.CLAUDE_CONFIG_DIR));
+  raw.push(...claudeDirsFromRc(homeDir));
+  try {
+    for (const name of fs.readdirSync(homeDir).sort()) {
+      if (!name.startsWith(".claude") || name === ".claude.json" || name.endsWith(".bak")) continue;
+      raw.push(path.resolve(path.join(homeDir, name)));
+    }
+  } catch {
+  }
+  const xdg = path.resolve(path.join(env.XDG_CONFIG_HOME || path.join(homeDir, ".config"), "claude"));
+  raw.push(xdg);
+  const unique = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const d of raw) {
+    if (seen.has(d)) continue;
+    if (d !== std && !isDir(path.join(d, "projects"))) continue;
+    seen.add(d);
+    unique.push(d);
+  }
+  return profileKeys("claude", unique, homeDir);
+}
+function codexProfileDirs(env, homeDir) {
+  const std = path.resolve(path.join(homeDir, ".codex"));
+  const raw = [std];
+  if (env.CODEX_HOME) raw.push(path.resolve(env.CODEX_HOME));
+  try {
+    for (const name of fs.readdirSync(homeDir).sort()) {
+      if (!name.startsWith(".codex") || name.endsWith(".bak")) continue;
+      raw.push(path.resolve(path.join(homeDir, name)));
+    }
+  } catch {
+  }
+  const unique = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const d of raw) {
+    if (seen.has(d)) continue;
+    if (d !== std && !isDir(path.join(d, "sessions"))) continue;
+    seen.add(d);
+    unique.push(d);
+  }
+  const map = profileKeys("codex", unique, homeDir);
+  const multi = path.join(homeDir, "Library", "Application Support", "Multi Codex", "profiles");
+  if (isDir(multi)) {
+    const used = new Set(map.values());
+    try {
+      for (const name of fs.readdirSync(multi).sort()) {
+        if (name.startsWith(".")) continue;
+        const dir = path.resolve(path.join(multi, name, "codex"));
+        if (map.has(dir) || !isDir(path.join(dir, "sessions"))) continue;
+        const key = uniqueProfileKey(profileKeyOf("codex", name, homeDir), used);
+        map.set(dir, key);
+      }
+    } catch {
+    }
+  }
+  return map;
+}
+function codexSessionFromFile(filePath) {
+  const base = path.basename(filePath, ".jsonl");
+  const stripped = base.replace(/^rollout-\d{4}-\d{2}-\d{2}T\d{2}-\d{2}-\d{2}(?:\.\d+)?-/i, "");
+  return { session: stripped, fromRollout: stripped !== base || base.startsWith("rollout") };
+}
+function collectClaudeFiles(dir, profile, cutoffMs, out) {
+  const projectsDir = path.join(dir, "projects");
+  let projects;
+  try {
+    projects = fs.readdirSync(projectsDir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const proj of projects) {
+    if (!proj.isDirectory()) continue;
+    const projPath = path.join(projectsDir, proj.name);
+    let entries;
+    try {
+      entries = fs.readdirSync(projPath, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const ent of entries) {
+      if (!ent.isFile() || !ent.name.endsWith(".jsonl")) continue;
+      const session = ent.name.slice(0, -6);
+      if (!SESSION_ID_RE.test(session)) continue;
+      const filePath = path.join(projPath, ent.name);
+      try {
+        const st = fs.statSync(filePath);
+        if (st.mtimeMs < cutoffMs || st.size <= 0) continue;
+        out.push({ tool: "claude", profile, session, fromRollout: false, filePath, mtimeMs: st.mtimeMs, size: st.size, ino: st.ino });
+      } catch {
+      }
+    }
+  }
+}
+function collectCodexFiles(dir, profile, cutoffMs, out) {
+  const walk = (cur, depth) => {
+    if (depth > 6) return;
+    let entries;
+    try {
+      entries = fs.readdirSync(cur, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const ent of entries) {
+      const full = path.join(cur, ent.name);
+      if (ent.isDirectory()) {
+        walk(full, depth + 1);
+      } else if (ent.isFile() && ent.name.endsWith(".jsonl")) {
+        const { session, fromRollout } = codexSessionFromFile(ent.name);
+        if (!SESSION_ID_RE.test(session)) continue;
+        try {
+          const st = fs.statSync(full);
+          if (st.mtimeMs < cutoffMs || st.size <= 0) continue;
+          out.push({ tool: "codex", profile, session, fromRollout, filePath: full, mtimeMs: st.mtimeMs, size: st.size, ino: st.ino });
+        } catch {
+        }
+      }
+    }
+  };
+  walk(path.join(dir, "sessions"), 0);
+}
+function readLinesFromOffset(filePath, startOffset, onLine) {
+  const fd = fs.openSync(filePath, "r");
+  try {
+    const buf = Buffer.allocUnsafe(CHUNK_BYTES);
+    let pos = startOffset;
+    let carry = Buffer.alloc(0);
+    let tooLong = false;
+    for (; ; ) {
+      const bytesRead = fs.readSync(fd, buf, 0, CHUNK_BYTES, pos);
+      if (bytesRead <= 0) break;
+      pos += bytesRead;
+      const chunk = buf.subarray(0, bytesRead);
+      let searchFrom = 0;
+      for (; ; ) {
+        const nl = chunk.indexOf(10, searchFrom);
+        if (nl === -1) {
+          const tail = chunk.subarray(searchFrom);
+          if (!tooLong) {
+            if (carry.length + tail.length > MAX_LINE_BYTES) {
+              carry = Buffer.alloc(0);
+              tooLong = true;
+            } else if (tail.length > 0) {
+              carry = carry.length === 0 ? Buffer.from(tail) : Buffer.concat([carry, tail]);
+            }
+          }
+          break;
+        }
+        const part = chunk.subarray(searchFrom, nl);
+        searchFrom = nl + 1;
+        if (tooLong) {
+          tooLong = false;
+          carry = Buffer.alloc(0);
+          continue;
+        }
+        if (carry.length + part.length <= MAX_LINE_BYTES) {
+          const line = carry.length === 0 ? part.toString("utf8") : Buffer.concat([carry, part]).toString("utf8");
+          carry = Buffer.alloc(0);
+          onLine(line);
+        } else {
+          carry = Buffer.alloc(0);
+        }
+      }
+    }
+    if (!tooLong && carry.length > 0) {
+      const text = carry.toString("utf8").trim();
+      if (text !== "") {
+        if (!text.startsWith("{") || !text.endsWith("}") || !onLine(text)) {
+          return pos - carry.length;
+        }
+      }
+    }
+    return pos;
+  } finally {
+    try {
+      fs.closeSync(fd);
+    } catch {
+    }
+  }
+}
+function parseClaudeLine(state, line) {
+  const trimmed = line.trim();
+  if (trimmed === "") return true;
+  if (trimmed[0] !== "{") return false;
+  if (!trimmed.includes('"usage"')) return true;
+  let raw;
+  try {
+    raw = JSON.parse(trimmed);
+  } catch {
+    return false;
+  }
+  if (!isRecord(raw)) return true;
+  if (raw.type !== void 0 && raw.type !== "assistant") return true;
+  const msg = isRecord(raw.message) ? raw.message : void 0;
+  if (!msg) return true;
+  if (msg.role !== void 0 && msg.role !== "assistant") return true;
+  const usage = isRecord(msg.usage) ? msg.usage : void 0;
+  if (!usage) return true;
+  const msgId = asShortId(msg.id ?? msg.message_id ?? raw.message_id ?? raw.messageId);
+  if (msgId) {
+    if (state.seenIds.has(msgId)) return true;
+    if (state.seenIds.size < MAX_SEEN_IDS) state.seenIds.add(msgId);
+  }
+  const input = asNonNegInt(usage.input_tokens);
+  const cacheCreate = asNonNegInt(usage.cache_creation_input_tokens);
+  const cacheRead = asNonNegInt(usage.cache_read_input_tokens);
+  const output = asNonNegInt(usage.output_tokens);
+  if (input === void 0 && cacheCreate === void 0 && cacheRead === void 0 && output === void 0) return true;
+  state.tokensIn += (input ?? 0) + (cacheCreate ?? 0) + (cacheRead ?? 0);
+  state.tokensOut += output ?? 0;
+  state.hasUsage = true;
+  const cost = asPositiveCost(raw.costUSD ?? raw.cost_usd ?? msg.costUSD ?? msg.cost_usd ?? usage.cost_usd ?? usage.costUSD);
+  if (cost !== void 0) {
+    state.costUsd += cost;
+    state.hasCost = true;
+  }
+  return true;
+}
+function parseCodexLine(state, line) {
+  const trimmed = line.trim();
+  if (trimmed === "") return true;
+  if (trimmed[0] !== "{") return false;
+  if (!trimmed.includes("token_count") && !trimmed.includes("session_meta")) return true;
+  let raw;
+  try {
+    raw = JSON.parse(trimmed);
+  } catch {
+    return false;
+  }
+  if (!isRecord(raw)) return true;
+  if (raw.type === "session_meta" && state.fromRollout && isRecord(raw.payload)) {
+    const id = asShortId(raw.payload.id ?? raw.payload.session_id);
+    if (id && SESSION_ID_RE.test(id)) state.session = id;
+    return true;
+  }
+  const payload = isRecord(raw.payload) ? raw.payload : isRecord(raw.msg) ? raw.msg : void 0;
+  const ev = raw.type === "token_count" || raw.event === "token_count" ? raw : payload && (payload.type === "token_count" || payload.event === "token_count") ? payload : void 0;
+  if (!ev) return true;
+  const info = isRecord(ev.info) ? ev.info : void 0;
+  const total = (info && (isRecord(info.total_token_usage) ? info.total_token_usage : isRecord(info.total_usage) ? info.total_usage : isRecord(info.usage) ? info.usage : void 0)) ?? (isRecord(ev.total_token_usage) ? ev.total_token_usage : isRecord(ev.total_usage) ? ev.total_usage : isRecord(ev.usage) ? ev.usage : info ?? ev);
+  const tin = asNonNegInt(total.input_tokens ?? total.tokens_in ?? total.prompt_tokens);
+  const tout = asNonNegInt(total.output_tokens ?? total.tokens_out ?? total.completion_tokens);
+  if (tin === void 0 && tout === void 0) return true;
+  state.tokensIn = tin ?? 0;
+  state.tokensOut = tout ?? 0;
+  state.hasUsage = true;
+  const cost = asPositiveCost(total.cost_usd ?? total.costUSD ?? ev.cost_usd ?? ev.costUSD ?? raw.cost_usd ?? raw.costUSD);
+  if (cost !== void 0) {
+    state.costUsd = cost;
+    state.hasCost = true;
+  }
+  return true;
+}
+function createUsageCollector(opts = {}) {
+  const files = /* @__PURE__ */ new Map();
+  return () => {
+    try {
+      const homeDir = opts.homeDir ?? home();
+      const env = opts.env ?? process.env;
+      const now = opts.now ? opts.now() : Date.now();
+      const windowMs = opts.windowMs ?? USAGE_WINDOW_MS;
+      const maxFiles = opts.maxFiles ?? USAGE_MAX_FILES;
+      const maxKeys = opts.maxKeys;
+      const cutoffMs = now - windowMs;
+      const candidates = [];
+      for (const [dir, profile] of claudeProfileDirs(env, homeDir)) {
+        collectClaudeFiles(dir, profile, cutoffMs, candidates);
+      }
+      for (const [dir, profile] of codexProfileDirs(env, homeDir)) {
+        collectCodexFiles(dir, profile, cutoffMs, candidates);
+      }
+      candidates.sort((a, b) => b.mtimeMs - a.mtimeMs || a.filePath.localeCompare(b.filePath));
+      const active = candidates.slice(0, maxFiles);
+      const activePaths = new Set(active.map((c) => c.filePath));
+      for (const k of files.keys()) {
+        if (!activePaths.has(k)) files.delete(k);
+      }
+      const usage = {};
+      const seenSessions = /* @__PURE__ */ new Set();
+      let keyCount = 0;
+      for (const c of active) {
+        let state = files.get(c.filePath);
+        if (!state || c.size < state.offset || c.ino !== 0 && state.ino !== 0 && c.ino !== state.ino) {
+          state = {
+            tool: c.tool,
+            profile: c.profile,
+            session: c.session,
+            fromRollout: c.fromRollout,
+            offset: 0,
+            size: 0,
+            mtimeMs: 0,
+            ino: c.ino,
+            tokensIn: 0,
+            tokensOut: 0,
+            costUsd: 0,
+            hasCost: false,
+            hasUsage: false,
+            seenIds: /* @__PURE__ */ new Set()
+          };
+          files.set(c.filePath, state);
+        } else {
+          state.profile = c.profile;
+        }
+        if (c.size > state.size || c.mtimeMs !== state.mtimeMs) {
+          try {
+            const parser = state.tool === "claude" ? parseClaudeLine : parseCodexLine;
+            const st = state;
+            state.offset = readLinesFromOffset(c.filePath, state.offset, (line) => parser(st, line));
+            state.size = c.size;
+            state.mtimeMs = c.mtimeMs;
+          } catch {
+            continue;
+          }
+        }
+        if (!state.hasUsage) continue;
+        const sessionKey = `${state.tool}:${state.profile}:${state.session}`;
+        if (seenSessions.has(sessionKey)) continue;
+        const base = `${state.tool}:${state.profile}:s:${state.session}`;
+        const kIn = `${base}:tokens_in`;
+        const kOut = `${base}:tokens_out`;
+        const kCost = `${base}:cost_usd`;
+        if (kIn.length > 80 || kOut.length > 80 || !parseUsageKey(kIn) || !parseUsageKey(kOut)) continue;
+        const includeCost = state.hasCost && kCost.length <= 80 && parseUsageKey(kCost) !== null;
+        const needed = includeCost ? 3 : 2;
+        if (maxKeys !== void 0 && keyCount + needed > maxKeys) continue;
+        seenSessions.add(sessionKey);
+        usage[kIn] = state.tokensIn;
+        usage[kOut] = state.tokensOut;
+        if (includeCost) usage[kCost] = Math.round(state.costUsd * 1e6) / 1e6;
+        keyCount += needed;
+      }
+      return keyCount > 0 ? { usage } : void 0;
+    } catch {
+      return void 0;
+    }
+  };
+}
+var basics = () => {
+  const total = os.totalmem();
+  const free = os.freemem();
+  return {
+    mem_total_mb: Math.round(total / 1048576),
+    mem_pct: total > 0 ? Math.round((total - free) / total * 1e3) / 10 : void 0,
+    load1: Math.round(os.loadavg()[0] * 100) / 100
+  };
+};
+var usageCounters = createUsageCollector({ maxKeys: USAGE_MAX_KEYS });
+var collectors = [basics, usageCounters];
+async function collectStats(list = collectors) {
+  const stats = {};
+  for (const c of list) {
+    try {
+      const part = await Promise.race([Promise.resolve(c()), new Promise((r) => setTimeout(() => r(void 0), 2e3).unref())]);
+      if (part) {
+        for (const [k, v] of Object.entries(part)) {
+          if (v === void 0) continue;
+          if (k === "usage" && isRecord(v)) {
+            const merged = isRecord(stats.usage) ? { ...stats.usage } : {};
+            for (const [uk, uv] of Object.entries(v)) {
+              if (typeof uv !== "number" || !Number.isFinite(uv)) continue;
+              if (!(uk in merged) && Object.keys(merged).length >= USAGE_MAX_KEYS) break;
+              merged[uk] = uv;
+            }
+            if (Object.keys(merged).length > 0) stats.usage = merged;
+          } else {
+            stats[k] = v;
+          }
+        }
+      }
+    } catch {
+    }
+  }
+  return Object.keys(stats).length > 0 ? stats : void 0;
+}
+
+// src/service/run.ts
+var FLUSH_EVERY_MS = 2e3;
+var FLUSH_BUDGET_MS = 5e3;
+var DISCOVERY_EVERY_MS = 6e4;
+var BEAT_EVERY_MS = 1e4;
+var BACKOFF_MAX_MS = 3e5;
+var LOG_MAX_BYTES = 1024 * 1024;
+var newSched = (now) => ({ heartbeat: now, flush: now, discovery: now + 5e3, beat: 0, failures: 0, quietUntil: 0, interval: MACHINE_HEARTBEAT_SECONDS * 1e3, logged: "", started: now, stop: false });
+function backoffMs(failures, random) {
+  const base = Math.min(BACKOFF_MAX_MS, MACHINE_HEARTBEAT_SECONDS * 1e3 * 2 ** Math.max(0, failures - 1));
+  return Math.max(MACHINE_MIN_INTERVAL_SECONDS * 1e3, Math.round(base * (0.8 + 0.4 * random())));
+}
+function log(st, now, state) {
+  if (st.logged === state) return;
+  st.logged = state;
+  try {
+    fs2.mkdirSync(configDir(), { recursive: true, mode: 448 });
+    const f = serviceLogFile();
+    let size = 0;
+    try {
+      size = fs2.statSync(f).size;
+    } catch {
+    }
+    if (size > LOG_MAX_BYTES) fs2.writeFileSync(f, "", { mode: 384 });
+    fs2.appendFileSync(f, `${new Date(now).toISOString()} ${state}
+`, { mode: 384 });
+  } catch {
+  }
+}
+async function call(deps, m, path2, body) {
+  try {
+    const r = await apiRequest(deps.ctx, m.host, `/api/v1/machine${path2}`, { method: "POST", token: m.token, body, timeoutMs: 1e4 });
+    if (r.status >= 200 && r.status < 300) return { outcome: "ok", json: r.json };
+    if (r.status === 401) return { outcome: "revoked" };
+    if (r.status === 429 || r.status >= 500) return { outcome: "retry" };
+    return { outcome: "drop" };
+  } catch {
+    return { outcome: "retry" };
+  }
+}
+function fail(st, deps, now, what) {
+  st.failures += 1;
+  st.lastError = what;
+  st.quietUntil = now + backoffMs(st.failures, deps.random ?? Math.random);
+  log(st, now, `error ${what}; retrying in ${Math.round((st.quietUntil - now) / 1e3)}s`);
+}
+function succeed(st, now) {
+  if (st.failures > 0) log(st, now, "online");
+  st.failures = 0;
+  st.quietUntil = 0;
+  st.lastOk = now;
+  st.lastError = void 0;
+}
+function beat(st, now) {
+  st.beat = now;
+  writeServiceState({ pid: process.pid, beat: now, started: st.started, ...st.lastOk ? { last_ok: st.lastOk } : {}, ...st.lastError ? { last_error: st.lastError } : {} });
+}
+async function serviceStep(deps, st) {
+  const now = deps.ctx.now();
+  const m = readMachine();
+  if (!m || m.revoked) {
+    log(st, now, "stopped: not connected");
+    return false;
+  }
+  const revoke = () => {
+    writeMachine({ ...m, revoked: true });
+    log(st, now, "stopped: the server no longer knows this machine (removed?)");
+    return false;
+  };
+  if (now - st.beat >= BEAT_EVERY_MS) {
+    beat(st, now);
+  }
+  if (now < st.quietUntil) return true;
+  if (now >= st.heartbeat) {
+    const stats = await collectStats(deps.collectors);
+    const r = await call(deps, m, "/heartbeat", { os: cliVersionOs(), cli_version: VERSION, ...stats ? { stats } : {} });
+    if (r.outcome === "revoked") return revoke();
+    if (r.outcome === "ok") {
+      const parsed = machineHeartbeatResponseSchema.safeParse(r.json);
+      const secs = parsed.success ? parsed.data.interval : MACHINE_HEARTBEAT_SECONDS;
+      st.interval = Math.max(MACHINE_MIN_INTERVAL_SECONDS, secs) * 1e3;
+      st.heartbeat = now + st.interval;
+      succeed(st, now);
+      if (st.logged === "") log(st, now, "online");
+    } else {
+      fail(st, deps, now, r.outcome === "drop" ? "heartbeat rejected" : "server unreachable");
+      st.heartbeat = st.quietUntil;
+      return true;
+    }
+  }
+  if (now >= st.flush) {
+    st.flush = now + FLUSH_EVERY_MS;
+    const claim = takeSpool(machineSpoolFile());
+    if (claim) {
+      const pending = claim.events;
+      const unsent = [];
+      const deadline = deps.ctx.now() + (deps.flushBudgetMs ?? FLUSH_BUDGET_MS);
+      let down = false;
+      let outOfTime = false;
+      for (let k = 0; k < pending.length; k += HOOK_BATCH_MAX) {
+        const batch = pending.slice(k, k + HOOK_BATCH_MAX);
+        if (down || outOfTime) {
+          unsent.push(...batch);
+          continue;
+        }
+        if (deps.ctx.now() >= deadline) {
+          unsent.push(...batch);
+          outOfTime = true;
+          continue;
+        }
+        const r = await call(deps, m, "/hooks", { events: batch });
+        if (r.outcome === "revoked") {
+          releaseSpool(claim, [...unsent, ...pending.slice(k)], machineSpoolFile());
+          return revoke();
+        }
+        if (r.outcome === "retry") {
+          unsent.push(...batch);
+          down = true;
+        }
+        beat(st, deps.ctx.now());
+      }
+      releaseSpool(claim, unsent, machineSpoolFile());
+      if (down) {
+        fail(st, deps, now, "server unreachable");
+        return true;
+      }
+      succeed(st, now);
+    }
+  }
+  if (now >= st.discovery) {
+    st.discovery = now + DISCOVERY_EVERY_MS;
+    let profiles = [];
+    try {
+      profiles = await (deps.profiles ?? (async () => buildProfiles(await scanProcesses({ platform: deps.ctx.platform ?? process.platform, run: deps.ctx.run ?? runCmd, env: deps.ctx.env }), deps.ctx.env)))();
+    } catch {
+    }
+    const r = await call(deps, m, "/discovery", { profiles });
+    if (r.outcome === "revoked") return revoke();
+    if (r.outcome === "retry") {
+      fail(st, deps, now, "server unreachable");
+      st.discovery = st.quietUntil;
+    } else if (r.outcome === "ok") succeed(st, now);
+  }
+  return true;
+}
+async function runService(deps) {
+  const st = newSched(deps.ctx.now());
+  const stop = () => {
+    st.stop = true;
+  };
+  process.on("SIGTERM", stop);
+  process.on("SIGINT", stop);
+  try {
+    while (!st.stop) {
+      const more = await serviceStep(deps, st);
+      if (!more) return 0;
+      await deps.ctx.sleep(500);
+    }
+    return 0;
+  } finally {
+    process.off("SIGTERM", stop);
+    process.off("SIGINT", stop);
+  }
+}
+export {
+  BACKOFF_MAX_MS,
+  BEAT_EVERY_MS,
+  DISCOVERY_EVERY_MS,
+  FLUSH_BUDGET_MS,
+  FLUSH_EVERY_MS,
+  LOG_MAX_BYTES,
+  backoffMs,
+  newSched,
+  runService,
+  serviceStep
+};