dexterm-cli 0.1.6 → 0.2.0

package/dist/packages/autotrade/src/service-recover.js

@@ -0,0 +1,232 @@
+// dexterm autotrade — safe resume after a crash or a reboot (0.2.0 card B, AUTOTRADE-SPEC §7.4 "Restart safety").
+//
+// The service records the fleet it hosts in service/state.json. When the next start finds that fleet without a
+// `fleet_end` (a crash, a kill -9, a power cut), recoverFleet() reads the fleet ledger for each strategy's runs and,
+// for every member run without a `run_end`:
+//   - checks its hash chain (a torn last line from a crash mid-write is dropped first and reported);
+//   - rebuilds the paper positions still open from the run's own events: `position_adopted` snapshots (an earlier
+//     resume) plus every `fill` of that position, minus the positions a `trade_closed` closed;
+//   - collects every coin the run took (any buy, any adopted position, an earlier resume's taken list).
+// The new run of the same strategy ADOPTS those positions (their exits keep running: stops, take-profits, trails,
+// max hold from the original open time) and REFUSES a new entry on every taken coin (vet rule
+// `service-resume-taken`), so a restart never buys a coin twice.
+//
+// Conservative choices, all in the direction of selling sooner and buying never:
+//   - an order still pending at the crash had no fill event, so it never happened: it is never re-sent;
+//   - an adopted position keeps no unfilled ladder tranche (no add after a restart) and its peak is the highest
+//     fill price (a trail measures from at most that);
+//   - a run whose chain is broken (an edited ledger) adopts nothing; its coins still count as taken.
+// Mode-agnostic: a paper position is adopted into the paper book; a real-mode position (card A) is the user's
+// executor's, and the same taken list keeps the next run from firing a second entry signal for it.
+import { existsSync, readFileSync } from 'node:fs';
+import { runFiles, verifyChain } from "./ledger.js";
+export const RESUME_TAKEN_RULE = 'service-resume-taken';
+/** Read a ledger file tolerating a torn final line (a crash mid-append); any other bad line is an error. */
+export function readLedgerTolerant(path) {
+    const lines = readFileSync(path, 'utf8').split('\n');
+    const events = [];
+    let torn = false;
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        if (!line.trim())
+            continue;
+        try {
+            events.push(JSON.parse(line));
+        }
+        catch (e) {
+            const rest = lines.slice(i + 1).some((l) => l.trim());
+            if (rest)
+                throw new Error(`line ${i + 1} is not JSON: ${e.message}`);
+            torn = true;
+        }
+    }
+    return { events, torn };
+}
+const num = (v, d = 0) => (typeof v === 'number' && Number.isFinite(v) ? v : d);
+/** A placeholder tick at the last known price, until the live feed sends a real one (focus marks the coin held). */
+export function placeholderTick(mint, symbol, t, price) {
+    return {
+        mint, t, kind: 'live', symbol, launchpad: 'unknown', createdAt: null, price, mcap: null, mcapResolved: null, mcapFlagged: false,
+        liq: null, vol5m: null, vol1h: null, vol24: null, buys5m: null, sells5m: null, buys24: null, sells24: null,
+        chg5m: null, chg1h: null, chg6h: null, chg24h: null, holders: null, top10: null, dev: null, mintAuth: null, freezeAuth: null, org: null,
+    };
+}
+/** Open positions and taken coins from ONE run's events (pure; the run is known to have no run_end). */
+export function positionsFromEvents(events) {
+    const symbols = new Map();
+    const base = new Map();
+    const fills = new Map();
+    const closed = new Set();
+    const taken = new Set();
+    for (const e of events) {
+        const mint = typeof e.mint === 'string' ? e.mint : null;
+        if (e.kind === 'candidate' && mint && typeof e.symbol === 'string')
+            symbols.set(mint, e.symbol);
+        else if (e.kind === 'position_adopted' && e.position && typeof e.position === 'object') {
+            const p = e.position;
+            if (typeof p.id === 'string' && typeof p.mint === 'string') {
+                base.set(p.id, structuredClone(p));
+                taken.add(p.mint);
+                symbols.set(p.mint, p.symbol);
+            }
+        }
+        else if (e.kind === 'fill' && typeof e.positionId === 'string' && mint) {
+            const f = { t: num(e.t), side: e.side === 'sell' ? 'sell' : 'buy', usd: num(e.usd), tokens: num(e.tokens), price: num(e.price), avgPrice: num(e.avgPrice, num(e.price)), impactPct: num(e.impactPct), partial: !!e.partial, reason: String(e.reason ?? '') };
+            const cur = fills.get(e.positionId) ?? { mint, profile: null, fills: [] };
+            if (typeof e.profile === 'string')
+                cur.profile ??= e.profile;
+            cur.fills.push(f);
+            fills.set(e.positionId, cur);
+            if (f.side === 'buy')
+                taken.add(mint);
+        }
+        else if (e.kind === 'trade_closed' && e.trade && typeof e.trade === 'object') {
+            const t = e.trade;
+            if (typeof t.id === 'string')
+                closed.add(t.id);
+            if (typeof t.mint === 'string' && typeof t.symbol === 'string')
+                symbols.set(t.mint, t.symbol);
+        }
+    }
+    const out = [];
+    const ids = new Set([...base.keys(), ...fills.keys()]);
+    for (const id of ids) {
+        if (closed.has(id))
+            continue;
+        const b = base.get(id);
+        const f = fills.get(id);
+        const mint = b?.mint ?? f.mint;
+        const symbol = symbols.get(mint) ?? b?.symbol ?? `${mint.slice(0, 4)}…`;
+        const p = b ?? {
+            id, mint, symbol, profileId: f?.profile ?? 'default', openedAt: f.fills[0].t, sessionId: null,
+            tokens: 0, origTokens: 0, costUsd: 0, realizedUsd: 0, entryPrice: 0, peakPrice: 0, tpFilled: 0, trailArmed: false,
+            ladder: [], fills: [], status: 'open', stuck: false, closedAt: null, exitReason: null, liqWindow: [], lowTapeSince: null,
+            lastTick: placeholderTick(mint, symbol, f.fills[0].t, f.fills[0].price), wakeSent: {},
+        };
+        for (const x of f?.fills ?? []) {
+            if (x.side === 'buy') {
+                const tokens = p.tokens + x.tokens;
+                p.entryPrice = tokens > 0 ? (p.entryPrice * p.tokens + x.price * x.tokens) / tokens : x.price;
+                p.tokens = tokens;
+                p.origTokens += x.tokens;
+                p.costUsd += x.usd;
+            }
+            else {
+                p.tokens = Math.max(0, p.tokens - x.tokens);
+                p.realizedUsd += x.usd;
+                const tp = /^tp(\d+)$/.exec(x.reason);
+                if (tp)
+                    p.tpFilled = Math.max(p.tpFilled, Number(tp[1]));
+                if (x.reason === 'cost-recovery')
+                    p.costRecovered = true;
+            }
+            p.peakPrice = Math.max(p.peakPrice, x.price);
+            p.fills.push(x);
+        }
+        if (p.origTokens > 0 && p.tokens < p.origTokens * 1e-6)
+            continue; // sold out without a trade_closed line (torn)
+        if (!(p.tokens > 0))
+            continue;
+        const last = p.fills[p.fills.length - 1];
+        p.ladder = [];
+        p.sessionId = null;
+        p.status = 'open';
+        p.troughPrice = p.troughPrice ?? Math.min(...p.fills.map((x) => x.price));
+        if (last)
+            p.lastTick = placeholderTick(mint, p.symbol || symbol, last.t, last.price);
+        p.symbol = p.symbol || symbol;
+        out.push(p);
+    }
+    return { positions: out, taken: [...taken] };
+}
+/** What the crashed fleet left behind, per strategy (empty when it ended cleanly). */
+export function recoverFleet(home, fleetId) {
+    const res = { fleetId, crashed: false, members: [], problems: [] };
+    let fpath;
+    try {
+        fpath = runFiles(home, fleetId).ledger;
+    }
+    catch (e) {
+        res.problems.push(e.message);
+        return res;
+    }
+    if (!existsSync(fpath)) {
+        res.problems.push(`no fleet ledger for ${fleetId}`);
+        return res;
+    }
+    let fleet;
+    try {
+        fleet = readLedgerTolerant(fpath).events;
+    }
+    catch (e) {
+        res.problems.push(`fleet ledger: ${e.message}`);
+        return res;
+    }
+    if (fleet.some((e) => e.kind === 'fleet_end'))
+        return res;
+    res.crashed = true;
+    const runsOf = new Map();
+    for (const e of fleet)
+        if (e.kind === 'member_start' && typeof e.member === 'string' && typeof e.runId === 'string')
+            runsOf.set(e.member, [...(runsOf.get(e.member) ?? []), e.runId]);
+    // An earlier resume's taken coins (the service writes them into the fleet ledger), so a second crash keeps them.
+    const takenBefore = new Map();
+    for (const e of fleet) {
+        if (e.kind !== 'service_resume' || !e.members || typeof e.members !== 'object')
+            continue;
+        for (const [id, v] of Object.entries(e.members)) {
+            if (Array.isArray(v?.taken))
+                takenBefore.set(id, [...(takenBefore.get(id) ?? []), ...v.taken.filter((x) => typeof x === 'string')]);
+        }
+    }
+    for (const id of takenBefore.keys())
+        if (!runsOf.has(id))
+            runsOf.set(id, []);
+    for (const [member, runIds] of runsOf) {
+        const m = { member, runIds: [], positions: [], taken: [], problems: [] };
+        const taken = new Set(takenBefore.get(member) ?? []);
+        for (const runId of runIds) {
+            let path;
+            try {
+                path = runFiles(home, runId).ledger;
+            }
+            catch (e) {
+                m.problems.push(e.message);
+                continue;
+            }
+            if (!existsSync(path))
+                continue;
+            let ev;
+            try {
+                ev = readLedgerTolerant(path);
+            }
+            catch (e) {
+                m.problems.push(`${runId}: ${e.message}; nothing adopted from it`);
+                continue;
+            }
+            if (ev.events.some((e) => e.kind === 'run_end'))
+                continue;
+            m.runIds.push(runId);
+            if (ev.torn)
+                m.problems.push(`${runId}: a torn last line (the crash) was dropped`);
+            const r = positionsFromEvents(ev.events);
+            for (const t of r.taken)
+                taken.add(t);
+            const chain = verifyChain(ev.events);
+            if (!chain.ok) {
+                m.problems.push(`${runId}: the hash chain breaks at event ${chain.at} (${chain.error}); nothing adopted from it, its coins stay taken`);
+                continue;
+            }
+            // A book numbers its positions p1, p2, …: an adopted one keeps its origin in its id so it never collides with
+            // the new run's own (an id that already names a run came from an earlier resume).
+            for (const p of r.positions)
+                if (!p.id.includes('/'))
+                    p.id = `${runId}/${p.id}`;
+            m.positions.push(...r.positions);
+        }
+        m.taken = [...taken];
+        if (m.runIds.length || m.problems.length || m.taken.length)
+            res.members.push(m);
+    }
+    return res;
+}

package/dist/packages/autotrade/src/service.js

@@ -0,0 +1,289 @@
+// dexterm autotrade — the always-on service: lock, heartbeat, stop marker, crash-loop guard and the `ensure`
+// decision (0.2.0 card B, AUTOTRADE-SPEC §7.4 / AT-10). Mode-agnostic: the service hosts `run --all` and never
+// decides paper or real itself.
+//
+// Shape (one per machine and DEXTERM_HOME):
+//   OS scheduler (LaunchAgent / systemd user timer / scheduled task), every 60 s and at login
+//     └─ `dexterm autotrade service ensure`   exits at once when the heartbeat is fresh; otherwise starts the service
+//          └─ `dexterm autotrade service run`  detached: service lock + heartbeat every 10 s + guard + the fleet
+//
+// Files under $DEXTERM_HOME/autotrade/service/:
+//   service.lock    {pid, bootAt, startedAt}: a stale lock is reclaimed only when that pid is dead (or from an older boot)
+//   heartbeat.json  dexterm-autotrade-service/1: state, fleet id, guard states; rewritten every 10 s; `stopped` on a
+//                   clean exit (anything else with a dead pid is a crash)
+//   STOP            the stop marker: `service stop`, a Telegram / Q-screen / CLI stop of the fleet, or a plain `touch`.
+//                   A clean stop stays stopped: `ensure` does nothing until `service start` removes it.
+//   starts.json     the crash-loop guard: every start after a crash, and the give-up record (`attention`)
+//   state.json      the fleet the service is running (recovery after a crash reads its ledgers, service-recover.ts)
+// Logs: $DEXTERM_HOME/autotrade/logs/service.log (+ .1), size-capped (BoundedLog).
+//
+// Crash-loop guard: a start that follows a crash waits a backoff (0, 0, 1, 2, 4 min for the 1st..5th crash in an
+// hour); the 6th crash within an hour writes `attention`, sends ONE notification and leaves the service down until
+// `dexterm autotrade service status --clear`. A clean stop and a manual `service start` never count.
+//
+// Nothing here holds a key, signs, touches a wallet or the network, and no model reaches any of it.
+import { appendFileSync, closeSync, existsSync, mkdirSync, openSync, readFileSync, renameSync, rmSync, statSync, writeSync } from 'node:fs';
+import { uptime } from 'node:os';
+import { join } from 'node:path';
+import { writeJsonAtomic } from "./ledger.js";
+export const SERVICE_SCHEMA = 'dexterm-autotrade-service/1';
+export const SERVICE_HEARTBEAT_MS = 10_000;
+/** `ensure` treats a heartbeat older than this as "not running" (three missed beats). */
+export const SERVICE_STALE_MS = 35_000;
+/** A live pid whose heartbeat is this old is hung: `ensure` ends it so the next tick restarts it. */
+export const SERVICE_HUNG_MS = 180_000;
+export const CRASH_WINDOW_MS = 60 * 60_000;
+/** Crash restarts allowed in CRASH_WINDOW_MS; the next one gives up. */
+export const MAX_CRASH_RESTARTS = 5;
+export const serviceDir = (home) => join(home, 'autotrade', 'service');
+export const serviceLogDir = (home) => join(home, 'autotrade', 'logs');
+export const serviceLockPath = (home) => join(serviceDir(home), 'service.lock');
+export const serviceHeartbeatPath = (home) => join(serviceDir(home), 'heartbeat.json');
+export const serviceStopPath = (home) => join(serviceDir(home), 'STOP');
+export const serviceStartsPath = (home) => join(serviceDir(home), 'starts.json');
+export const serviceStatePath = (home) => join(serviceDir(home), 'state.json');
+export const serviceLogPath = (home) => join(serviceLogDir(home), 'service.log');
+const mkdirs = (home) => { mkdirSync(serviceDir(home), { recursive: true, mode: 0o700 }); };
+const readJson = (path) => { try {
+    return JSON.parse(readFileSync(path, 'utf8'));
+}
+catch {
+    return null;
+} };
+export const pidAlive = (pid) => {
+    if (!Number.isInteger(pid) || pid <= 0)
+        return false;
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (e) {
+        return e.code === 'EPERM';
+    }
+};
+/** This boot's start, rounded to the minute (a pid from an older boot is never this process). */
+export const bootAt = () => Math.round((Date.now() - uptime() * 1000) / 60_000) * 60_000;
+/** Take the service lock (O_EXCL). A holder is stale only when its pid is dead or it is from an older boot. */
+export function acquireServiceLock(home, d = {}) {
+    mkdirs(home);
+    const path = serviceLockPath(home);
+    const alive = d.alive ?? pidAlive;
+    const lock = { pid: d.pid ?? process.pid, bootAt: d.boot ?? bootAt(), startedAt: d.now ?? Date.now() };
+    let reclaimed = null;
+    for (let attempt = 0; attempt < 2; attempt++) {
+        try {
+            const fd = openSync(path, 'wx', 0o600);
+            writeSync(fd, `${JSON.stringify(lock)}\n`);
+            closeSync(fd);
+            return { ok: true, lock, reclaimed };
+        }
+        catch (e) {
+            if (e.code !== 'EEXIST')
+                throw e;
+        }
+        const held = readJson(path);
+        if (held && typeof held.pid === 'number' && alive(held.pid) && Math.abs((held.bootAt ?? 0) - lock.bootAt) <= 5 * 60_000)
+            return { ok: false, holder: held };
+        reclaimed = held;
+        rmSync(path, { force: true });
+    }
+    throw new Error(`could not take ${path}`);
+}
+export function releaseServiceLock(home, pid = process.pid) {
+    const held = readJson(serviceLockPath(home));
+    if (held && held.pid === pid)
+        rmSync(serviceLockPath(home), { force: true });
+}
+/** The lock holder when its pid is alive (and from this boot), else null. */
+export function liveServiceHolder(home, alive = pidAlive, boot = bootAt()) {
+    const held = readJson(serviceLockPath(home));
+    if (!held || typeof held.pid !== 'number' || !alive(held.pid))
+        return null;
+    return Math.abs((held.bootAt ?? 0) - boot) <= 5 * 60_000 ? held : null;
+}
+export function writeServiceHeartbeat(home, hb) {
+    mkdirs(home);
+    writeJsonAtomic(serviceHeartbeatPath(home), hb);
+}
+export function readServiceHeartbeat(home) {
+    const d = readJson(serviceHeartbeatPath(home));
+    return d && d.schema === SERVICE_SCHEMA && typeof d.pid === 'number' && typeof d.heartbeatAt === 'number' ? d : null;
+}
+export function writeStopMarker(home, by, reason, now = Date.now()) {
+    mkdirs(home);
+    const m = { at: now, by, reason: reason.slice(0, 200) };
+    writeJsonAtomic(serviceStopPath(home), m);
+    return m;
+}
+/** The stop marker, or null. A file that is not our JSON (a plain `touch`) is still a stop. */
+export function readStopMarker(home) {
+    const p = serviceStopPath(home);
+    if (!existsSync(p))
+        return null;
+    const d = readJson(p);
+    if (d && typeof d.at === 'number')
+        return { at: d.at, by: (d.by ?? 'file'), reason: typeof d.reason === 'string' ? d.reason : 'stop' };
+    let at = 0;
+    try {
+        at = statSync(p).mtimeMs;
+    }
+    catch { /* raced */ }
+    return { at, by: 'file', reason: 'the STOP file is present' };
+}
+export const clearStopMarker = (home) => { rmSync(serviceStopPath(home), { force: true }); };
+const EMPTY_STARTS = { crashStarts: [], lastStartAt: null, attention: null, downNotifiedAt: null };
+export function readStarts(home) {
+    const d = readJson(serviceStartsPath(home));
+    if (!d)
+        return { ...EMPTY_STARTS, crashStarts: [] };
+    return {
+        crashStarts: Array.isArray(d.crashStarts) ? d.crashStarts.filter((t) => typeof t === 'number') : [],
+        lastStartAt: typeof d.lastStartAt === 'number' ? d.lastStartAt : null,
+        attention: d.attention && typeof d.attention.at === 'number' ? { at: d.attention.at, why: String(d.attention.why ?? ''), notified: !!d.attention.notified } : null,
+        downNotifiedAt: typeof d.downNotifiedAt === 'number' ? d.downNotifiedAt : null,
+    };
+}
+export function writeStarts(home, d) { mkdirs(home); writeJsonAtomic(serviceStartsPath(home), d); }
+/** Wait before the n-th crash restart within the window (1-based): 0, 0, 1, 2, 4 minutes. */
+export function crashBackoffMs(n) { return n <= 2 ? 0 : Math.min(15, 2 ** (n - 3)) * 60_000; }
+/** `service status --clear`: forget the crash history and lift the give-up. */
+export function clearAttention(home) {
+    const d = { ...readStarts(home), crashStarts: [], attention: null };
+    writeStarts(home, d);
+    return d;
+}
+/** True when the last run did not end cleanly (a heartbeat that is not `stopped`, with no live holder). */
+export function lastRunCrashed(hb) { return !!hb && hb.state !== 'stopped'; }
+/**
+ * What one scheduler tick does. Pure: the caller reads the files and carries the action out (startService,
+ * the kill, the notification, writeStarts).
+ */
+export function ensureDecision(i) {
+    if (i.holder) {
+        const age = i.heartbeat && i.heartbeat.pid === i.holder.pid ? i.now - i.heartbeat.heartbeatAt : i.now - i.holder.startedAt;
+        if (age <= SERVICE_STALE_MS)
+            return { action: 'noop', why: `running (pid ${i.holder.pid}, heartbeat ${Math.round(age / 1000)} s old)` };
+        if (age >= SERVICE_HUNG_MS)
+            return { action: 'kill-hung', pid: i.holder.pid, why: `pid ${i.holder.pid} is alive but its heartbeat is ${Math.round(age / 1000)} s old (hung)` };
+        return { action: 'noop', why: `pid ${i.holder.pid} is alive; heartbeat ${Math.round(age / 1000)} s old (starting or busy)` };
+    }
+    if (i.stop)
+        return { action: 'noop', why: `stopped (${i.stop.reason}); \`dexterm autotrade service start\` starts it again` };
+    if (i.starts.attention)
+        return { action: 'give-up', why: i.starts.attention.why, notify: !i.starts.attention.notified };
+    if (i.panic)
+        return { action: 'noop', why: `the panic switch is engaged (${i.panic}); nothing starts until \`dexterm wallet resume\`` };
+    const crashed = lastRunCrashed(i.heartbeat);
+    if (!crashed)
+        return { action: 'start', crashed: false, why: i.heartbeat ? 'the service is not running' : 'first start', notifyDown: false };
+    const recent = i.starts.crashStarts.filter((t) => i.now - t < CRASH_WINDOW_MS);
+    if (recent.length >= MAX_CRASH_RESTARTS) {
+        return { action: 'give-up', why: `crash loop: ${recent.length + 1} crashes within an hour; the service stays down until \`dexterm autotrade service status --clear\``, notify: true };
+    }
+    const wait = crashBackoffMs(recent.length + 1);
+    const last = recent.length ? Math.max(...recent) : 0;
+    if (last && i.now - last < wait)
+        return { action: 'wait', why: `crash ${recent.length + 1} within the hour: backing off ${Math.round(wait / 60_000)} min`, untilMs: last + wait };
+    const notifyDown = !i.starts.downNotifiedAt || i.now - i.starts.downNotifiedAt >= CRASH_WINDOW_MS;
+    return { action: 'start', crashed: true, why: `the last run ended without a clean stop (pid ${i.heartbeat.pid}); restarting`, notifyDown };
+}
+/** Record what a decision did in starts.json (the caller does the process work). */
+export function applyEnsure(home, d, now) {
+    const s = readStarts(home);
+    s.crashStarts = s.crashStarts.filter((t) => now - t < CRASH_WINDOW_MS);
+    if (d.action === 'start') {
+        s.lastStartAt = now;
+        if (d.crashed)
+            s.crashStarts.push(now);
+        if (d.notifyDown)
+            s.downNotifiedAt = now;
+    }
+    else if (d.action === 'give-up') {
+        s.attention = { at: s.attention?.at ?? now, why: d.why, notified: true };
+    }
+    writeStarts(home, s);
+    return s;
+}
+export function writeServiceState(home, d) { mkdirs(home); writeJsonAtomic(serviceStatePath(home), d); }
+export function readServiceState(home) {
+    const d = readJson(serviceStatePath(home));
+    return d && typeof d.startedAt === 'number' ? { fleetId: typeof d.fleetId === 'string' ? d.fleetId : null, startedAt: d.startedAt, pid: Number(d.pid) || 0 } : null;
+}
+// ───────────────────────────── the bounded log ─────────────────────────────
+export const LOG_MAX_BYTES = 4 * 1024 * 1024;
+/**
+ * An append-only log capped at maxBytes: past the cap the file moves to `.1` (replacing the older one) and a new
+ * file starts, so the log never holds more than about 2 × maxBytes. Each line is stamped; write errors are swallowed
+ * (a full disk must never stop the exits).
+ */
+export class BoundedLog {
+    path;
+    max;
+    size;
+    constructor(path, maxBytes = LOG_MAX_BYTES) {
+        this.path = path;
+        this.max = maxBytes;
+        try {
+            mkdirSync(join(path, '..'), { recursive: true, mode: 0o700 });
+        }
+        catch { /* reported on write */ }
+        try {
+            this.size = statSync(path).size;
+        }
+        catch {
+            this.size = 0;
+        }
+        if (this.size >= this.max)
+            this.rotate();
+    }
+    rotate() {
+        try {
+            renameSync(this.path, `${this.path}.1`);
+        }
+        catch { /* nothing to move */ }
+        this.size = 0;
+    }
+    line(s, now = Date.now()) {
+        const text = `${new Date(now).toISOString()} ${s.replace(/\n+$/, '')}\n`;
+        const n = Buffer.byteLength(text);
+        if (this.size + n > this.max)
+            this.rotate();
+        try {
+            appendFileSync(this.path, text, { mode: 0o600 });
+            this.size += n;
+        }
+        catch { /* never the service's problem */ }
+    }
+    /** A stream-like face for code that writes chunks (the fleet's stdout / stderr). */
+    writer(prefix = '') {
+        let buf = '';
+        return {
+            write: (s) => {
+                buf += s;
+                let i;
+                while ((i = buf.indexOf('\n')) >= 0) {
+                    this.line(prefix + buf.slice(0, i));
+                    buf = buf.slice(i + 1);
+                }
+                if (buf.length > 8192) {
+                    this.line(prefix + buf);
+                    buf = '';
+                }
+                return true;
+            },
+        };
+    }
+}
+/** The last n lines of the service log (and the rotated one before it when short). */
+export function tailServiceLog(home, n = 50) {
+    const read = (p) => { try {
+        return readFileSync(p, 'utf8').split('\n').filter(Boolean);
+    }
+    catch {
+        return [];
+    } };
+    const cur = read(serviceLogPath(home));
+    if (cur.length >= n)
+        return cur.slice(-n);
+    return [...read(`${serviceLogPath(home)}.1`), ...cur].slice(-n);
+}