@crvouga/dev-fleet 0.7.0 → 0.9.0

package/src/worker-reboot.ts

@@ -0,0 +1,129 @@
+import { playbookConnection } from './ssh';
+import type { PackagePlaybook } from './platform/ansible';
+import { blocking, type Check, type FleetNode } from './types';
+
+/** Why fleet-sync reboots a worker: its first converge, which nothing can be
+ * running on yet, or a maintenance reboot the operator asked for
+ * (`--maintenance-reboot`) to apply installed updates.
+ */
+export type RebootReason = 'first-converge' | 'maintenance';
+
+/** The boot-policy codes a reboot settles: the managed power files were
+ * written after this boot, or the running login manager has not loaded them.
+ */
+const SETTLED_BY_REBOOT = [
+  'UBUNTU_MAINTENANCE_REBOOT_PENDING',
+  'UBUNTU_SESSION_POLICY_PENDING',
+];
+
+/** The converge ran (its bootstrap passed) and says a reboot is needed. */
+export function rebootNeeded(checks: Check[]): boolean {
+  if (
+    checks.some((check) => check.id.startsWith('bootstrap:') && blocking(check))
+  )
+    return false;
+  return checks.some(
+    (check) =>
+      (check.id === 'ubuntu:boot-policy' &&
+        SETTLED_BY_REBOOT.includes(check.summary)) ||
+      (check.id === 'worker:reboot-pending' && check.status !== 'pass')
+  );
+}
+
+/** A maintenance run goes on to the next worker only once this one is back
+ * and ready: a reboot that failed, or one after which the worker is not
+ * ready, stops the rest.
+ */
+export function rebootStopsRollout(node: { checks: Check[] }): boolean {
+  const reboot = node.checks.find((check) => check.id === 'worker:reboot');
+  if (!reboot) return false;
+  if (reboot.summary === 'WORKER_REBOOT_FAILED') return true;
+  return reboot.status === 'pass' && node.checks.some(blocking);
+}
+
+/** Installed updates wait for a reboot: what --maintenance-reboot applies. */
+export function updatesPending(checks: Check[]): boolean {
+  return checks.some(
+    (check) => check.id === 'worker:reboot-pending' && check.status !== 'pass'
+  );
+}
+
+/** The home of the account a roster entry converges, from its workspace. */
+export function workerHome(node: FleetNode): string | null {
+  const suffix = '/.local/share/personal/fleet';
+  return node.workspace.endsWith(suffix)
+    ? node.workspace.slice(0, -suffix.length) || null
+    : null;
+}
+
+/** Reboots one worker through ansible/ubuntu/reboot.yml, run from the
+ * manager: only while its T3 runs no agent turn (unless `force`), waiting
+ * until it answers again. The play's output is read for its own codes only.
+ */
+export async function rebootWorker(
+  node: FleetNode,
+  request: { revision: string; reason: RebootReason; force?: boolean },
+  playbook: PackagePlaybook
+): Promise<Check> {
+  const home = workerHome(node);
+  if (!home)
+    return {
+      id: 'worker:reboot',
+      status: 'fail',
+      summary: 'WORKER_REBOOT_FAILED',
+      remedy: {
+        action:
+          'The roster names no workspace under the account home, so the worker was not rebooted. Rerun fleet-sync once it is enrolled.',
+      },
+    };
+  // `user@alias` only for a worker whose account this run created.
+  // A worker reached from declared data logs in as its declared account.
+  const connection = playbookConnection(node);
+  const [login, target] = node.ssh.includes('@')
+    ? node.ssh.split('@', 2)
+    : [connection.user ?? '', node.ssh];
+  const result = await playbook(
+    'ubuntu/reboot.yml',
+    {
+      target,
+      login,
+      home,
+      revision: request.revision,
+      reason: request.reason,
+      force: Boolean(request.force),
+      ssh_options: connection.options,
+    },
+    // The play waits up to 900 seconds for the worker to answer again.
+    1_200_000
+  );
+  if (result.ok)
+    return {
+      id: 'worker:reboot',
+      status: 'pass',
+      summary:
+        request.reason === 'first-converge'
+          ? 'Rebooted once after its first converge, which no agent turn ran on; it answered again and was converged once more.'
+          : 'Rebooted for maintenance while no agent turn ran; it answered again and was converged once more.',
+    };
+  if (result.stdout.includes('WORKER_REBOOT_BUSY'))
+    return {
+      id: 'worker:reboot',
+      // A busy worker is left alone, and the others still go: its boot
+      // policy or its pending updates still say a reboot is needed.
+      status: 'warn',
+      summary: 'WORKER_REBOOT_BUSY',
+      remedy: {
+        action:
+          'An agent turn is running on the worker, so it was not rebooted. Rerun fleet-sync --maintenance-reboot once the turn has ended, or add --force to end it.',
+      },
+    };
+  return {
+    id: 'worker:reboot',
+    status: 'fail',
+    summary: 'WORKER_REBOOT_FAILED',
+    remedy: {
+      action:
+        'The reboot did not complete, or the worker did not answer within 15 minutes. Check its console with the provider, then rerun fleet-sync.',
+    },
+  };
+}

package/src/worker-records.ts

@@ -0,0 +1,305 @@
+import { spawnSync } from 'node:child_process';
+import { readFileSync } from 'node:fs';
+import { isAbsolute, join } from 'node:path';
+import { record } from './config';
+import { DefinitionError, HOST_KEY } from './definition';
+
+/** One worker as an infrastructure tool describes it, without naming the
+ * tool or the provider: schema/worker-record.schema.json. A file or command
+ * `workerRecords` in fleet.json names returns a list of them; dev-fleet only
+ * reads it and never creates a machine.
+ */
+export interface WorkerRecord {
+  id: string;
+  /** The tailnet name the worker joins under; preferred to `address`. */
+  tailnetName?: string;
+  /** An address SSH reaches the worker at, when it has no tailnet name. */
+  address?: string;
+  user: string;
+  /** The port sshd listens on; 22 when absent. */
+  port?: number;
+  /** The SSH host public key, "TYPE BASE64": pinned, never learned.
+   * Without one the key is the one the fleet state pins (fleet-node-seed
+   * --apply --yes), and until then every session is refused.
+   */
+  hostKey?: string;
+  /** The port the worker's T3 server listens on; 3773 when absent. */
+  t3Port?: number;
+  labels?: Record<string, string>;
+  billing?: { hourlyRate: number; currency?: string; note?: string };
+}
+
+/** Where `workerRecords` reads records from. */
+export type RecordSource = { file: string } | { command: string[] };
+
+/** Runs a record command in the project directory; its standard output. */
+export type RecordCommand = (
+  argv: string[],
+  directory: string
+) => string | null;
+
+const ID = /^[a-z][a-z0-9-]{0,62}$/;
+const HOST = /^[a-zA-Z0-9][a-zA-Z0-9._-]{0,252}$/;
+const USER = /^[a-z_][a-z0-9_-]{0,31}$/;
+const RECORD_FIELDS = [
+  'id',
+  'tailnetName',
+  'address',
+  'user',
+  'port',
+  'hostKey',
+  't3Port',
+  'labels',
+  'billing',
+];
+/** Port of the worker T3 server when a record names none. */
+const T3_PORT = 3773;
+
+function invalid(
+  path: string,
+  expected: string,
+  actual: unknown,
+  code = actual === undefined ? 'DEFINITION_MISSING' : 'DEFINITION_INVALID'
+): never {
+  throw new DefinitionError({
+    code,
+    path,
+    expected,
+    actual:
+      actual === undefined
+        ? 'nothing'
+        : Array.isArray(actual)
+          ? `an array of ${actual.length}`
+          : record(actual)
+            ? 'an object'
+            : JSON.stringify(actual).slice(0, 64),
+  });
+}
+
+function string(
+  value: unknown,
+  pattern: RegExp,
+  path: string,
+  expected: string
+): string {
+  if (typeof value !== 'string' || !pattern.test(value))
+    invalid(path, expected, value);
+  return value as string;
+}
+
+function port(value: unknown, path: string): number {
+  if (!Number.isInteger(value) || Number(value) < 1 || Number(value) > 65535)
+    invalid(path, 'a port from 1 to 65535', value);
+  return value as number;
+}
+
+/** One record, or a DefinitionError naming the field that is wrong. */
+export function parseRecord(value: unknown, path: string): WorkerRecord {
+  if (!record(value)) return invalid(path, 'an object', value);
+  const unknown = Object.keys(value).find(
+    (key) => !RECORD_FIELDS.includes(key)
+  );
+  if (unknown !== undefined)
+    invalid(
+      `${path}.${unknown}`,
+      `one of ${RECORD_FIELDS.join(', ')}`,
+      value[unknown],
+      'DEFINITION_UNKNOWN'
+    );
+  const id = string(value['id'], ID, `${path}.id`, 'a lowercase id');
+  if (value['tailnetName'] === undefined && value['address'] === undefined)
+    invalid(`${path}.tailnetName`, 'a tailnet name, or an address', undefined);
+  return {
+    id,
+    ...(value['tailnetName'] === undefined
+      ? {}
+      : {
+          tailnetName: string(
+            value['tailnetName'],
+            HOST,
+            `${path}.tailnetName`,
+            'a host name'
+          ),
+        }),
+    ...(value['address'] === undefined
+      ? {}
+      : {
+          address: string(
+            value['address'],
+            HOST,
+            `${path}.address`,
+            'a host name or IP address'
+          ),
+        }),
+    user: string(value['user'], USER, `${path}.user`, 'a login name'),
+    ...(value['port'] === undefined
+      ? {}
+      : { port: port(value['port'], `${path}.port`) }),
+    ...(value['hostKey'] === undefined
+      ? {}
+      : {
+          hostKey: string(
+            value['hostKey'],
+            HOST_KEY,
+            `${path}.hostKey`,
+            'one SSH public key, "TYPE BASE64"'
+          ),
+        }),
+    ...(value['t3Port'] === undefined
+      ? {}
+      : { t3Port: port(value['t3Port'], `${path}.t3Port`) }),
+    ...(value['labels'] === undefined
+      ? {}
+      : { labels: value['labels'] as Record<string, string> }),
+    ...(value['billing'] === undefined
+      ? {}
+      : { billing: value['billing'] as WorkerRecord['billing'] & object }),
+  };
+}
+
+/** A record list: `{ "version": 1, "workers": [...] }`. */
+export function parseRecords(value: unknown, path: string): WorkerRecord[] {
+  if (!record(value)) return invalid(path, 'an object', value);
+  if (value['version'] !== 1) invalid(`${path}.version`, '1', value['version']);
+  const workers = value['workers'];
+  if (!Array.isArray(workers) || workers.length > 64)
+    return invalid(
+      `${path}.workers`,
+      'an array of at most 64 records',
+      workers
+    );
+  return workers.map((entry, index) =>
+    parseRecord(entry, `${path}.workers[${index}]`)
+  );
+}
+
+/** The worker a record declares, as fleet.json would write it. Labels and
+ * billing are checked by the definition itself.
+ */
+export function recordWorker(entry: WorkerRecord): Record<string, unknown> {
+  return {
+    id: entry.id,
+    os: 'linux',
+    network: {
+      tailscaleName: entry.tailnetName ?? entry.address,
+      user: entry.user,
+      sshPort: entry.port ?? 22,
+      t3Port: entry.t3Port ?? T3_PORT,
+      ...(entry.hostKey ? { hostKey: entry.hostKey } : {}),
+    },
+    ...(entry.labels ? { labels: entry.labels } : {}),
+    ...(entry.billing ? { billing: entry.billing } : {}),
+    origin: 'records',
+  };
+}
+
+function source(value: unknown, path: string): RecordSource {
+  if (record(value) && typeof value['file'] === 'string' && !value['command'])
+    return { file: value['file'] };
+  if (
+    record(value) &&
+    Array.isArray(value['command']) &&
+    value['command'].length > 0 &&
+    value['command'].every((entry) => typeof entry === 'string') &&
+    value['file'] === undefined
+  )
+    return { command: value['command'] as string[] };
+  return invalid(path, '{ "file": PATH } or { "command": [ARGV] }', value);
+}
+
+/** Runs a record command where fleet.json is, for at most a minute. */
+export const runRecordCommand: RecordCommand = (argv, directory) => {
+  const result = spawnSync(argv[0]!, argv.slice(1), {
+    cwd: directory,
+    encoding: 'utf8',
+    timeout: 60_000,
+    maxBuffer: 1024 * 1024,
+    stdio: ['ignore', 'pipe', 'ignore'],
+  });
+  return result.status === 0 ? result.stdout : null;
+};
+
+function readSource(
+  entry: RecordSource,
+  path: string,
+  directory: string,
+  command: RecordCommand
+): unknown {
+  let text: string | null;
+  if ('file' in entry) {
+    try {
+      text = readFileSync(
+        isAbsolute(entry.file) ? entry.file : join(directory, entry.file),
+        'utf8'
+      );
+    } catch (error) {
+      // The tool that writes the file removes it with the last machine
+      // (`tofu destroy`): no file is no record.
+      if ((error as NodeJS.ErrnoException).code === 'ENOENT')
+        return { version: 1, workers: [] };
+      text = null;
+    }
+  } else text = command(entry.command, directory);
+  if (text === null)
+    invalid(
+      `${path}.${'file' in entry ? 'file' : 'command'}`,
+      'a readable list of worker records',
+      'nothing',
+      'DEFINITION_UNREADABLE'
+    );
+  try {
+    return JSON.parse(text!) as unknown;
+  } catch {
+    return invalid(
+      path,
+      'JSON',
+      'text that is not JSON',
+      'DEFINITION_UNREADABLE'
+    );
+  }
+}
+
+/** fleet.json with the workers its record sources return appended to the
+ * inline list, and `workerRecords` itself gone: what the rest of dev-fleet
+ * reads, installs and stores. A record whose ID is already declared is
+ * refused, naming the record.
+ */
+export function expandRecords(
+  value: unknown,
+  directory: string,
+  command: RecordCommand = runRecordCommand
+): unknown {
+  if (!record(value) || value['workerRecords'] === undefined) return value;
+  const { workerRecords, ...rest } = value;
+  if (!Array.isArray(workerRecords) || workerRecords.length > 8)
+    return invalid(
+      '$.workerRecords',
+      'a list of at most 8 record sources',
+      workerRecords
+    );
+  const inline = Array.isArray(rest['workers']) ? rest['workers'] : [];
+  const seen = new Set(
+    inline.map((entry) => (record(entry) ? entry['id'] : undefined))
+  );
+  const added: Record<string, unknown>[] = [];
+  workerRecords.forEach((raw, index) => {
+    const path = `$.workerRecords[${index}]`;
+    const entry = source(raw, path);
+    const records = parseRecords(
+      readSource(entry, path, directory, command),
+      path
+    );
+    records.forEach((found, position) => {
+      if (seen.has(found.id))
+        invalid(
+          `${path}.workers[${position}].id`,
+          'an id no other worker has',
+          found.id,
+          'DEFINITION_DUPLICATE'
+        );
+      seen.add(found.id);
+      added.push(recordWorker(found));
+    });
+  });
+  return { ...rest, workers: [...inline, ...added] };
+}

package/src/worker-seed.ts

@@ -0,0 +1,143 @@
+import { mkdtemp, readFile, rm } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { parse, stringify } from 'yaml';
+import type { MachineDefinition } from './definition';
+import { FleetUsageError } from './errors';
+import { PACKAGE_ROOT } from './package-info';
+import type { Runner } from './types';
+
+/** What a new worker's first boot needs, and nothing that outlives it: the
+ * worker account with the manager's public key, the privilege rule
+ * fleet-sync expects, a host key generated here so the manager pins it before
+ * the machine ever answers (no trust on first use), and a short-lived,
+ * single-use Tailscale auth key that is deleted once the machine has joined.
+ */
+export interface SeedInput {
+  worker: MachineDefinition;
+  /** The manager's SSH public key: one line of a `.pub` file. */
+  managerKey: string;
+  /** From the secrets provider, by purpose (`tailnet-auth-key`). */
+  authKey: string;
+  /** Generated with ssh-keygen for this seed. */
+  hostKey: { private: string; public: string };
+  /** `tailscale` in ansible/ubuntu/policy.json: version and key digest. */
+  tailscale: { version: string; keySha256: string };
+  /** The codename of the fleet's Ubuntu release, from the Ubuntu policy. */
+  codename: string;
+  /** A self-hosted control server the machine joins; the hosted Tailscale's
+   * when absent.
+   */
+  loginServer?: string;
+}
+
+/** The login server the Tailscale client uses when it is told none. */
+const TAILSCALE_LOGIN_SERVER = 'https://controlplane.tailscale.com';
+
+const PUBLIC_KEY =
+  /^(ssh-ed25519|ecdsa-sha2-nistp256|ssh-rsa) [A-Za-z0-9+/=]{16,}( [^\n]*)?$/;
+
+/** The user data of one worker: bootstrap/worker-seed.yaml with every
+ * `${NAME}` filled. Values replace whole placeholders inside parsed strings,
+ * so none of them can change the document's structure.
+ */
+export async function seedUserData(
+  input: SeedInput,
+  root = PACKAGE_ROOT
+): Promise<Record<string, unknown>> {
+  const { worker } = input;
+  const user = worker.network?.user;
+  if (!user)
+    throw new FleetUsageError(
+      `${worker.id} declares no network block; the seed needs its user and Tailscale name.`
+    );
+  if (!PUBLIC_KEY.test(input.managerKey.trim()))
+    throw new FleetUsageError(
+      'The manager public key is not one OpenSSH public key line.'
+    );
+  // A Headscale key has no fixed prefix; the hosted Tailscale's does.
+  if (
+    !(
+      input.loginServer
+        ? /^[A-Za-z0-9_-]{16,256}$/
+        : /^tskey-auth-[A-Za-z0-9-]{8,200}$/
+    ).test(input.authKey)
+  )
+    throw new FleetUsageError(
+      'The tailnet-auth-key secret is not a Tailscale auth key (tskey-auth-…). Use a short-lived, single-use, tagged key.'
+    );
+  const values: Record<string, string> = {
+    HOSTNAME: worker.network!.tailscaleName.split('.')[0]!,
+    USER: user,
+    MANAGER_KEY: input.managerKey.trim(),
+    HOST_KEY_PRIVATE: input.hostKey.private,
+    HOST_KEY_PUBLIC: input.hostKey.public,
+    AUTH_KEY: input.authKey,
+    TAILSCALE_VERSION: input.tailscale.version,
+    TAILSCALE_KEY_SHA256: input.tailscale.keySha256,
+    CODENAME: input.codename,
+    LOGIN_SERVER: input.loginServer ?? TAILSCALE_LOGIN_SERVER,
+  };
+  const template = parse(
+    await readFile(join(root, 'bootstrap/worker-seed.yaml'), 'utf8')
+  ) as unknown;
+  return fill(template, values) as Record<string, unknown>;
+}
+
+function fill(value: unknown, values: Record<string, string>): unknown {
+  if (typeof value === 'string')
+    return value.replace(/\$\{([A-Z0-9_]+)\}/g, (_, name: string) => {
+      const found = values[name];
+      if (found === undefined)
+        throw new Error(`The seed template names an unknown value ${name}.`);
+      return found;
+    });
+  if (Array.isArray(value)) return value.map((item) => fill(item, values));
+  if (value && typeof value === 'object')
+    return Object.fromEntries(
+      Object.entries(value).map(([key, item]) => [key, fill(item, values)])
+    );
+  return value;
+}
+
+/** Cloud-init user data, or an Ubuntu autoinstall file that carries it. */
+export function renderSeed(
+  userData: Record<string, unknown>,
+  autoinstall: boolean
+): string {
+  const document = autoinstall
+    ? {
+        autoinstall: {
+          version: 1,
+          ssh: { 'install-server': true, 'allow-pw': false },
+          'user-data': userData,
+        },
+      }
+    : userData;
+  return `#cloud-config\n${stringify(document, { lineWidth: 0 })}`;
+}
+
+/** A new ed25519 host key, generated in a private directory that is removed
+ * afterwards.
+ */
+export async function generateHostKey(
+  id: string,
+  run: Runner
+): Promise<SeedInput['hostKey']> {
+  const directory = await mkdtemp(join(tmpdir(), 'devfleet-seed-'));
+  try {
+    const path = join(directory, 'host');
+    const made = await run(
+      ['ssh-keygen', '-q', '-t', 'ed25519', '-N', '', '-C', id, '-f', path],
+      { timeoutMs: 20_000 }
+    );
+    if (!made.ok)
+      throw new FleetUsageError('ssh-keygen could not make a host key.');
+    return {
+      private: await readFile(path, 'utf8'),
+      public: (await readFile(`${path}.pub`, 'utf8')).trim(),
+    };
+  } finally {
+    await rm(directory, { recursive: true, force: true });
+  }
+}

package/src/worker-sizing.ts

@@ -0,0 +1,76 @@
+import policy from '../ansible/ubuntu/policy.json';
+
+/** How much of a machine a worker needs, and the lines its disk and memory
+ * policy draws, all declared under `sizing` in ansible/ubuntu/policy.json.
+ * Each line is a share of the disk or of memory between a lower and an upper
+ * bound, so it scales from a small rented instance to a large workstation.
+ * `tasks/sizing.yml` computes the same numbers for Ansible.
+ */
+export type ThresholdName = keyof typeof policy.sizing.thresholds;
+
+export interface MachineSize {
+  memoryMiB: number;
+  /** The size of the root filesystem (or the home one, for its own lines). */
+  diskMiB: number;
+  cpus: number;
+}
+
+/** One line in MiB for a machine whose disk or memory (as the line says)
+ * is `totalMiB`: its share, never under its lower bound or over its upper. */
+export function threshold(name: ThresholdName, totalMiB: number): number {
+  const line = policy.sizing.thresholds[name];
+  return Math.min(
+    line.maxMiB,
+    Math.max(line.minMiB, Math.floor(line.share * totalMiB))
+  );
+}
+
+/** Every line, for a machine of this size. */
+export function thresholds(size: {
+  memoryMiB: number;
+  diskMiB: number;
+}): Record<ThresholdName, number> {
+  return Object.fromEntries(
+    (Object.keys(policy.sizing.thresholds) as ThresholdName[]).map((name) => [
+      name,
+      threshold(
+        name,
+        policy.sizing.thresholds[name].of === 'memory'
+          ? size.memoryMiB
+          : size.diskMiB
+      ),
+    ])
+  ) as Record<ThresholdName, number>;
+}
+
+export const MINIMUM_WORKER: MachineSize = policy.sizing.minimumWorker;
+
+/** What a machine lacks to be a worker, each as `memory 2048 MiB < 3584
+ * MiB`; empty when it has the stated minimum. */
+export function belowMinimum(size: MachineSize): string[] {
+  const lacks: string[] = [];
+  if (size.memoryMiB < MINIMUM_WORKER.memoryMiB)
+    lacks.push(
+      `memory ${size.memoryMiB} MiB < ${MINIMUM_WORKER.memoryMiB} MiB`
+    );
+  if (size.diskMiB < MINIMUM_WORKER.diskMiB)
+    lacks.push(`disk ${size.diskMiB} MiB < ${MINIMUM_WORKER.diskMiB} MiB`);
+  if (size.cpus < MINIMUM_WORKER.cpus)
+    lacks.push(`CPUs ${size.cpus} < ${MINIMUM_WORKER.cpus}`);
+  return lacks;
+}
+
+/** The user workloads' share of memory, from `userMemoryMax` ("90%"). */
+function userShare(): number {
+  const percent = /^(\d{1,3})%$/.exec(policy.resourceSafety.userMemoryMax);
+  return percent ? Number(percent[1]) / 100 : 1;
+}
+
+/** How many agent sessions run side by side within the memory policy:
+ * what user workloads may use, less what T3 keeps for itself, in sessions
+ * of the estimated size `sizing.agentSessionMiB`. Never below zero.
+ */
+export function supportedSessions(memoryMiB: number): number {
+  const usable = memoryMiB * userShare() - policy.sizing.t3ReservedMiB;
+  return Math.max(0, Math.floor(usable / policy.sizing.agentSessionMiB));
+}

package/src/cli/schedule-logs.ts

@@ -1,36 +0,0 @@
-import { readdirSync, readFileSync, statSync, writeFileSync } from 'node:fs';
-import { join } from 'node:path';
-
-/** The most a scheduled job's log may hold; a longer one keeps its newest
- * quarter.
- */
-export const SCHEDULE_LOG_BYTES = 1024 * 1024;
-
-/** Caps the schedule's own logs (`<label>.out.log`, `<label>.err.log`) at the
- * start of every scheduled run. launchd and systemd append to them, so the
- * newest lines are what is kept. Nothing else in the directory is touched.
- */
-export function capScheduleLogs(
-  directory: string,
-  limit = SCHEDULE_LOG_BYTES
-): void {
-  let names: string[];
-  try {
-    names = readdirSync(directory);
-  } catch {
-    return;
-  }
-  for (const name of names) {
-    if (!/^[a-z0-9-]+\.(out|err)\.log$/.test(name)) continue;
-    const path = join(directory, name);
-    try {
-      const stat = statSync(path);
-      if (!stat.isFile() || stat.size <= limit) continue;
-      const kept = readFileSync(path).subarray(stat.size - limit / 4);
-      const start = kept.indexOf(10) + 1;
-      writeFileSync(path, kept.subarray(start), { mode: 0o600 });
-    } catch {
-      // A log that cannot be capped is capped by the next run.
-    }
-  }
-}