@h-rig/runtime 0.0.6-alpha.0

package/dist/src/control-plane/authority-files.js

@@ -0,0 +1,582 @@
+// @bun
+// packages/runtime/src/control-plane/authority-files.ts
+import { existsSync as existsSync2, mkdirSync, readFileSync, writeFileSync, appendFileSync, copyFileSync, statSync, readdirSync, chmodSync } from "fs";
+import { homedir } from "os";
+import { dirname as dirname2, join, relative, resolve as resolve2 } from "path";
+import { randomUUID } from "crypto";
+import { parse as parseToml, stringify as stringifyToml } from "smol-toml";
+
+// packages/runtime/src/layout.ts
+import { existsSync } from "fs";
+import { basename, dirname, resolve } from "path";
+function resolveMonorepoRoot(projectRoot) {
+  const normalizedProjectRoot = resolve(projectRoot);
+  const explicit = process.env.MONOREPO_ROOT?.trim();
+  if (explicit) {
+    const explicitRoot = resolve(explicit);
+    const explicitParent = dirname(explicitRoot);
+    if (basename(explicitParent) === ".worktrees") {
+      const owner = dirname(explicitParent);
+      const ownerHasGit = existsSync(resolve(owner, ".git"));
+      const ownerHasTaskConfig = existsSync(resolve(owner, ".rig", "task-config.json"));
+      const ownerHasRigConfig = existsSync(resolve(owner, "rig.config.ts"));
+      if (ownerHasGit && (ownerHasTaskConfig || ownerHasRigConfig)) {
+        return owner;
+      }
+      throw new Error(`MONOREPO_ROOT points to worktree ${explicitRoot}, but the owner checkout is incomplete at ${owner}.`);
+    }
+    if (!existsSync(resolve(explicitRoot, ".git"))) {
+      throw new Error(`MONOREPO_ROOT points to ${explicitRoot}, but no git checkout was found there.`);
+    }
+    const hasTaskConfig = existsSync(resolve(explicitRoot, ".rig", "task-config.json"));
+    const hasRigConfig = existsSync(resolve(explicitRoot, "rig.config.ts"));
+    if (!hasTaskConfig && !hasRigConfig) {
+      throw new Error(`MONOREPO_ROOT points to ${explicitRoot}, but neither .rig/task-config.json nor rig.config.ts exists there.`);
+    }
+    return explicitRoot;
+  }
+  const projectParent = dirname(normalizedProjectRoot);
+  if (basename(projectParent) === ".worktrees") {
+    const worktreeOwner = dirname(projectParent);
+    const ownerHasGit = existsSync(resolve(worktreeOwner, ".git"));
+    const ownerHasTaskConfig = existsSync(resolve(worktreeOwner, ".rig", "task-config.json"));
+    const ownerHasRigConfig = existsSync(resolve(worktreeOwner, "rig.config.ts"));
+    if (ownerHasGit && (ownerHasTaskConfig || ownerHasRigConfig)) {
+      return worktreeOwner;
+    }
+  }
+  return normalizedProjectRoot;
+}
+
+// packages/runtime/src/control-plane/authority-files.ts
+function readTomlFile(path, fallback) {
+  if (!existsSync2(path))
+    return fallback;
+  const raw = readFileSync(path, "utf8");
+  if (!raw.trim())
+    return fallback;
+  return parseToml(raw);
+}
+function writeTomlFile(path, value) {
+  mkdirSync(dirname2(path), { recursive: true });
+  writeFileSync(path, `${stringifyToml(value).trimEnd()}
+`, "utf8");
+}
+function normalizeString(value) {
+  return typeof value === "string" && value.trim().length > 0 ? value.trim() : null;
+}
+function normalizeStringArray(value) {
+  if (!Array.isArray(value))
+    return [];
+  return value.map((entry) => normalizeString(entry)).filter((entry) => entry !== null);
+}
+function normalizePort(value) {
+  const port = typeof value === "number" ? value : Number(value);
+  return Number.isInteger(port) && port > 0 && port <= 65535 ? port : 7890;
+}
+function loadRemoteEndpointsToml(projectRoot) {
+  const paths = resolveAuthorityPaths(projectRoot);
+  const parsed = readTomlFile(paths.remoteEndpointsPath, { version: 1, endpoints: {} });
+  return {
+    version: parsed.version ?? 1,
+    endpoints: parsed.endpoints ?? {}
+  };
+}
+function loadRemoteSecretsToml(projectRoot) {
+  const paths = resolveAuthorityPaths(projectRoot);
+  const parsed = readTomlFile(paths.remoteSecretsPath, { version: 1, secrets: {} });
+  return {
+    version: parsed.version ?? 1,
+    secrets: parsed.secrets ?? {}
+  };
+}
+function saveRemoteEndpointsToml(projectRoot, payload) {
+  const paths = resolveAuthorityPaths(projectRoot);
+  writeTomlFile(paths.remoteEndpointsPath, payload);
+}
+function saveRemoteSecretsToml(projectRoot, payload) {
+  const paths = resolveAuthorityPaths(projectRoot);
+  writeTomlFile(paths.remoteSecretsPath, payload);
+  try {
+    chmodSync(paths.remoteSecretsPath, 384);
+  } catch {}
+}
+function resolveAuthorityPaths(projectRoot) {
+  const normalizedRoot = resolve2(projectRoot);
+  const stateRoot = resolveAuthorityStateRoot(normalizedRoot);
+  const stateDir = resolveAuthorityStateDir(normalizedRoot);
+  return {
+    projectRoot: normalizedRoot,
+    harnessRoot: resolve2(normalizedRoot, "rig"),
+    runsDir: resolve2(stateRoot, "runs"),
+    remoteDir: resolve2(stateRoot, "remote"),
+    stateDir,
+    remoteEndpointsPath: resolve2(stateRoot, "remote", "endpoints.toml"),
+    remoteSecretsPath: resolve2(stateDir, "remote-secrets.toml")
+  };
+}
+function resolveAuthorityStateRoot(projectRoot) {
+  const normalizedRoot = resolve2(projectRoot);
+  const taskWorkspace = process.env.RIG_TASK_WORKSPACE?.trim();
+  if (taskWorkspace) {
+    return resolve2(taskWorkspace, ".rig");
+  }
+  const stateDir = process.env.RIG_STATE_DIR?.trim();
+  if (stateDir) {
+    return dirname2(resolve2(stateDir));
+  }
+  const logsDir = process.env.RIG_LOGS_DIR?.trim();
+  if (logsDir) {
+    return dirname2(resolve2(logsDir));
+  }
+  const sessionFile = process.env.RIG_SESSION_FILE?.trim();
+  if (sessionFile) {
+    return dirname2(dirname2(resolve2(sessionFile)));
+  }
+  const projectStateRoot = resolve2(normalizedRoot, ".rig");
+  if (existsSync2(projectStateRoot)) {
+    return projectStateRoot;
+  }
+  return resolve2(normalizedRoot, ".rig");
+}
+function resolveAuthorityStateDir(projectRoot) {
+  const explicit = process.env.RIG_STATE_DIR?.trim();
+  if (explicit) {
+    return resolve2(explicit);
+  }
+  return resolve2(resolveAuthorityStateRoot(projectRoot), "state");
+}
+function resolveAuthorityProjectStateDir(projectRoot) {
+  const explicit = process.env.RIG_STATE_DIR?.trim();
+  if (explicit) {
+    return resolve2(explicit);
+  }
+  return resolve2(resolve2(projectRoot), ".rig", "state");
+}
+function readJsonAtPath(path, fallback) {
+  if (!existsSync2(path)) {
+    return fallback;
+  }
+  try {
+    return JSON.parse(readFileSync(path, "utf-8"));
+  } catch {
+    return fallback;
+  }
+}
+function writeJsonAtPath(path, value) {
+  mkdirSync(dirname2(path), { recursive: true });
+  writeFileSync(path, `${JSON.stringify(value, null, 2)}
+`, "utf8");
+  return path;
+}
+function readAuthorityStateJson(projectRoot, relativePath, fallback) {
+  return readJsonAtPath(resolve2(resolveAuthorityStateDir(projectRoot), relativePath), fallback);
+}
+function writeAuthorityStateJson(projectRoot, relativePath, value) {
+  return writeJsonAtPath(resolve2(resolveAuthorityStateDir(projectRoot), relativePath), value);
+}
+function readAuthorityProjectStateJson(projectRoot, relativePath, fallback) {
+  return readJsonAtPath(resolve2(resolveAuthorityProjectStateDir(projectRoot), relativePath), fallback);
+}
+function writeAuthorityProjectStateJson(projectRoot, relativePath, value) {
+  return writeJsonAtPath(resolve2(resolveAuthorityProjectStateDir(projectRoot), relativePath), value);
+}
+function resolveAuthorityArtifactsRoot(projectRoot) {
+  const explicit = process.env.ARTIFACTS_DIR?.trim();
+  if (explicit) {
+    return resolve2(explicit);
+  }
+  const projectArtifactsRoot = resolve2(projectRoot, "artifacts");
+  if (existsSync2(projectArtifactsRoot)) {
+    return projectArtifactsRoot;
+  }
+  const taskWorkspace = process.env.RIG_TASK_WORKSPACE?.trim();
+  if (taskWorkspace) {
+    return resolve2(taskWorkspace, "artifacts");
+  }
+  if (process.env.MONOREPO_ROOT?.trim()) {
+    return resolve2(resolveMonorepoRoot(projectRoot), "artifacts");
+  }
+  const normalizedRoot = resolve2(projectRoot);
+  const projectLooksLikeMonorepo = existsSync2(resolve2(normalizedRoot, ".git")) && existsSync2(resolve2(normalizedRoot, ".rig", "task-config.json"));
+  if (!projectLooksLikeMonorepo) {
+    return projectArtifactsRoot;
+  }
+  return resolve2(resolveMonorepoRoot(projectRoot), "artifacts");
+}
+function resolveAuthorityRuntimeDir(projectRoot) {
+  return resolve2(resolveAuthorityStateRoot(projectRoot), "runtime");
+}
+function uniquePaths(paths) {
+  const seen = new Set;
+  const result = [];
+  for (const value of paths) {
+    const normalized = normalizeString(value);
+    if (!normalized || seen.has(normalized))
+      continue;
+    seen.add(normalized);
+    result.push(normalized);
+  }
+  return result;
+}
+function listAuthorityRunRoots(projectRoot) {
+  const normalizedRoot = resolve2(projectRoot);
+  const monorepoRoot = resolveMonorepoRoot(normalizedRoot);
+  return uniquePaths([
+    resolve2(resolveAuthorityStateRoot(normalizedRoot), "runs"),
+    resolve2(monorepoRoot, ".rig", "runs")
+  ]);
+}
+function listAuthorityArtifactRoots(projectRoot) {
+  return uniquePaths([
+    resolveAuthorityArtifactsRoot(projectRoot)
+  ]);
+}
+function listAuthorityRuntimeAgentsRoots(projectRoot) {
+  return uniquePaths([
+    resolve2(resolveAuthorityRuntimeDir(projectRoot), "agents")
+  ]);
+}
+function listAuthorityRemoteEndpoints(projectRoot) {
+  const endpoints = loadRemoteEndpointsToml(projectRoot).endpoints ?? {};
+  const secrets = loadRemoteSecretsToml(projectRoot).secrets ?? {};
+  return Object.values(endpoints).map((entry) => {
+    const token = secrets[entry.secret_ref] ?? "";
+    return {
+      id: entry.id,
+      alias: entry.alias,
+      host: entry.host,
+      port: normalizePort(entry.port),
+      token,
+      autoConnect: Boolean(entry.auto_connect),
+      addedAt: entry.created_at,
+      updatedAt: entry.updated_at,
+      lastConnectedAt: normalizeString(entry.last_connected_at) ?? null,
+      labels: normalizeStringArray(entry.labels),
+      capabilities: normalizeStringArray(entry.capabilities),
+      transport: normalizeString(entry.transport) ?? "websocket",
+      secretRef: entry.secret_ref
+    };
+  }).sort((left, right) => left.alias.localeCompare(right.alias));
+}
+function nextRemoteEndpointRecord(input) {
+  const timestamp = new Date().toISOString();
+  const secretRef = input.existing?.secret_ref ?? randomUUID();
+  return {
+    record: {
+      id: input.endpointId ?? input.existing?.id ?? randomUUID(),
+      alias: input.alias,
+      host: input.host,
+      port: normalizePort(input.port),
+      transport: normalizeString(input.transport) ?? normalizeString(input.existing?.transport) ?? "websocket",
+      auto_connect: input.autoConnect ?? input.existing?.auto_connect ?? false,
+      labels: input.labels ?? normalizeStringArray(input.existing?.labels),
+      capabilities: input.capabilities ?? normalizeStringArray(input.existing?.capabilities),
+      secret_ref: secretRef,
+      created_at: input.existing?.created_at ?? timestamp,
+      updated_at: timestamp,
+      last_connected_at: input.existing?.last_connected_at ?? null
+    },
+    secretRef
+  };
+}
+function upsertAuthorityRemoteEndpoint(projectRoot, input) {
+  const endpointsToml = loadRemoteEndpointsToml(projectRoot);
+  const secretsToml = loadRemoteSecretsToml(projectRoot);
+  const existing = Object.values(endpointsToml.endpoints ?? {}).find((entry) => entry.alias === input.alias) ?? null;
+  const { record, secretRef } = nextRemoteEndpointRecord({
+    endpointId: input.endpointId,
+    existing,
+    alias: input.alias,
+    host: input.host,
+    port: input.port,
+    token: input.token,
+    autoConnect: input.autoConnect,
+    transport: input.transport,
+    labels: input.labels,
+    capabilities: input.capabilities
+  });
+  endpointsToml.endpoints = {
+    ...endpointsToml.endpoints ?? {},
+    [record.id]: record
+  };
+  secretsToml.secrets = {
+    ...secretsToml.secrets ?? {},
+    [secretRef]: input.token
+  };
+  saveRemoteEndpointsToml(projectRoot, endpointsToml);
+  saveRemoteSecretsToml(projectRoot, secretsToml);
+  return listAuthorityRemoteEndpoints(projectRoot).find((entry) => entry.id === record.id);
+}
+function updateAuthorityRemoteEndpoint(projectRoot, input) {
+  const endpointsToml = loadRemoteEndpointsToml(projectRoot);
+  const secretsToml = loadRemoteSecretsToml(projectRoot);
+  const current = Object.values(endpointsToml.endpoints ?? {}).find((entry) => input.endpointId && entry.id === input.endpointId || input.alias && entry.alias === input.alias);
+  if (!current)
+    return null;
+  const record = {
+    ...current,
+    alias: normalizeString(input.alias) ?? current.alias,
+    host: normalizeString(input.host) ?? current.host,
+    port: input.port !== undefined ? normalizePort(input.port) : current.port,
+    auto_connect: input.autoConnect ?? current.auto_connect,
+    transport: normalizeString(input.transport) ?? current.transport,
+    labels: input.labels ?? normalizeStringArray(current.labels),
+    capabilities: input.capabilities ?? normalizeStringArray(current.capabilities),
+    updated_at: new Date().toISOString()
+  };
+  endpointsToml.endpoints = {
+    ...endpointsToml.endpoints ?? {},
+    [record.id]: record
+  };
+  if (input.token !== undefined) {
+    secretsToml.secrets = {
+      ...secretsToml.secrets ?? {},
+      [record.secret_ref]: input.token
+    };
+  }
+  saveRemoteEndpointsToml(projectRoot, endpointsToml);
+  saveRemoteSecretsToml(projectRoot, secretsToml);
+  return listAuthorityRemoteEndpoints(projectRoot).find((entry) => entry.id === record.id) ?? null;
+}
+function removeAuthorityRemoteEndpoint(projectRoot, endpointIdOrAlias) {
+  const endpointsToml = loadRemoteEndpointsToml(projectRoot);
+  const secretsToml = loadRemoteSecretsToml(projectRoot);
+  const entry = Object.values(endpointsToml.endpoints ?? {}).find((candidate) => candidate.id === endpointIdOrAlias || candidate.alias === endpointIdOrAlias);
+  if (!entry)
+    return false;
+  const nextEndpoints = { ...endpointsToml.endpoints ?? {} };
+  delete nextEndpoints[entry.id];
+  const nextSecrets = { ...secretsToml.secrets ?? {} };
+  delete nextSecrets[entry.secret_ref];
+  saveRemoteEndpointsToml(projectRoot, { version: endpointsToml.version ?? 1, endpoints: nextEndpoints });
+  saveRemoteSecretsToml(projectRoot, { version: secretsToml.version ?? 1, secrets: nextSecrets });
+  return true;
+}
+function markAuthorityRemoteEndpointConnected(projectRoot, endpointId, connectedAt = new Date().toISOString()) {
+  const endpointsToml = loadRemoteEndpointsToml(projectRoot);
+  const entry = endpointsToml.endpoints?.[endpointId];
+  if (!entry)
+    return;
+  endpointsToml.endpoints = {
+    ...endpointsToml.endpoints ?? {},
+    [endpointId]: {
+      ...entry,
+      last_connected_at: connectedAt,
+      updated_at: connectedAt
+    }
+  };
+  saveRemoteEndpointsToml(projectRoot, endpointsToml);
+}
+function importLegacyRemoteEndpoints(projectRoot, legacyPath = join(homedir(), ".config", "rig", "remotes.toml")) {
+  if (!existsSync2(legacyPath)) {
+    return { imported: 0, skipped: 0, sourcePath: legacyPath };
+  }
+  const parsed = readTomlFile(legacyPath, { version: 1, remotes: {} });
+  let imported = 0;
+  let skipped = 0;
+  for (const [alias, entry] of Object.entries(parsed.remotes ?? {})) {
+    const host = normalizeString(entry.host);
+    const token = normalizeString(entry.token);
+    if (!host || !token) {
+      skipped += 1;
+      continue;
+    }
+    upsertAuthorityRemoteEndpoint(projectRoot, {
+      alias,
+      host,
+      port: normalizePort(entry.port),
+      token
+    });
+    imported += 1;
+  }
+  return { imported, skipped, sourcePath: legacyPath };
+}
+function doctorAuthorityRemoteEndpoints(projectRoot) {
+  const paths = resolveAuthorityPaths(projectRoot);
+  const endpoints = loadRemoteEndpointsToml(projectRoot).endpoints ?? {};
+  const secrets = loadRemoteSecretsToml(projectRoot).secrets ?? {};
+  const missingSecrets = Object.values(endpoints).filter((entry) => !normalizeString(secrets[entry.secret_ref])).map((entry) => entry.alias);
+  const warnings = [];
+  if (!existsSync2(paths.remoteEndpointsPath)) {
+    warnings.push("Remote endpoint manifest is missing.");
+  }
+  if (!existsSync2(paths.remoteSecretsPath)) {
+    warnings.push("Remote secret store is missing.");
+  }
+  return {
+    manifestPath: paths.remoteEndpointsPath,
+    secretsPath: paths.remoteSecretsPath,
+    endpointCount: Object.keys(endpoints).length,
+    missingSecrets,
+    warnings
+  };
+}
+function resolveAuthorityRunDir(projectRoot, runId) {
+  const roots = listAuthorityRunRoots(projectRoot);
+  for (const runsDir of roots) {
+    const candidate = resolve2(runsDir, runId);
+    if (existsSync2(candidate)) {
+      return candidate;
+    }
+  }
+  return resolve2(roots[0] ?? resolveAuthorityPaths(projectRoot).runsDir, runId);
+}
+function appendJsonlRecord(path, value) {
+  mkdirSync(dirname2(path), { recursive: true });
+  appendFileSync(path, `${JSON.stringify(value)}
+`, "utf8");
+}
+function writeJsonFile(path, value) {
+  mkdirSync(dirname2(path), { recursive: true });
+  writeFileSync(path, `${JSON.stringify(value, null, 2)}
+`, "utf8");
+}
+function readJsonFile(path, fallback) {
+  if (!existsSync2(path))
+    return fallback;
+  try {
+    return JSON.parse(readFileSync(path, "utf8"));
+  } catch {
+    return fallback;
+  }
+}
+function listAuthorityRuns(projectRoot) {
+  const runs = new Map;
+  for (const runsDir of listAuthorityRunRoots(projectRoot)) {
+    if (!existsSync2(runsDir))
+      continue;
+    for (const runId of readDirRuns(runsDir)) {
+      if (runs.has(runId))
+        continue;
+      const entry = readJsonFile(resolve2(runsDir, runId, "run.json"), null);
+      if (entry && runBelongsToProject(projectRoot, entry, runsDir)) {
+        runs.set(runId, entry);
+      }
+    }
+  }
+  return [...runs.values()].sort((left, right) => right.updatedAt.localeCompare(left.updatedAt));
+}
+function runBelongsToProject(projectRoot, run, runsDir) {
+  const normalizedRoot = resolve2(projectRoot);
+  const record = run;
+  const recordedProjectRoot = normalizeString(record.projectRoot);
+  if (recordedProjectRoot) {
+    return resolve2(recordedProjectRoot) === normalizedRoot;
+  }
+  const projectLocalRunsDir = resolve2(normalizedRoot, ".rig", "runs");
+  if (isPathWithin(projectLocalRunsDir, resolve2(runsDir))) {
+    return true;
+  }
+  const pathFields = [
+    run.worktreePath,
+    run.artifactRoot,
+    run.logRoot,
+    run.sessionPath,
+    run.sessionLogPath
+  ].filter((value) => typeof value === "string" && value.trim().length > 0);
+  if (pathFields.length === 0) {
+    return true;
+  }
+  return pathFields.some((value) => isPathWithin(normalizedRoot, resolve2(value)));
+}
+function isPathWithin(root, candidate) {
+  const relativePath = relative(root, candidate);
+  return relativePath === "" || !relativePath.startsWith("..") && !relativePath.startsWith(`/`) && !relativePath.startsWith(`\\`);
+}
+function readDirRuns(runsDir) {
+  try {
+    return readdirSync(runsDir, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => entry.name);
+  } catch {
+    return [];
+  }
+}
+function readAuthorityRun(projectRoot, runId) {
+  for (const runsDir of listAuthorityRunRoots(projectRoot)) {
+    const entry = readJsonFile(resolve2(runsDir, runId, "run.json"), null);
+    if (entry) {
+      return entry;
+    }
+  }
+  return null;
+}
+function resolveTaskArtifactDirs(projectRoot, taskId) {
+  const candidates = [];
+  const seen = new Set;
+  const add = (value) => {
+    const normalized = normalizeString(value);
+    if (!normalized || seen.has(normalized))
+      return;
+    seen.add(normalized);
+    candidates.push(normalized);
+  };
+  for (const run of listAuthorityRuns(projectRoot)) {
+    if (run.taskId !== taskId)
+      continue;
+    add(run.artifactRoot);
+    if (run.worktreePath) {
+      add(resolve2(run.worktreePath, "artifacts", taskId));
+    }
+  }
+  for (const artifactsRoot of listAuthorityArtifactRoots(projectRoot)) {
+    add(resolve2(artifactsRoot, taskId));
+  }
+  return candidates;
+}
+function readJsonlFile(path) {
+  if (!existsSync2(path))
+    return [];
+  return readFileSync(path, "utf8").split(/\r?\n/).map((line) => line.trim()).filter(Boolean).flatMap((line) => {
+    try {
+      return [JSON.parse(line)];
+    } catch {
+      return [];
+    }
+  });
+}
+function copyFileIfPresent(sourcePath, targetPath) {
+  if (!existsSync2(sourcePath))
+    return false;
+  mkdirSync(dirname2(targetPath), { recursive: true });
+  copyFileSync(sourcePath, targetPath);
+  return true;
+}
+function fileSizeIfPresent(path) {
+  try {
+    return statSync(path).size;
+  } catch {
+    return null;
+  }
+}
+export {
+  writeJsonFile,
+  writeAuthorityStateJson,
+  writeAuthorityProjectStateJson,
+  upsertAuthorityRemoteEndpoint,
+  updateAuthorityRemoteEndpoint,
+  resolveTaskArtifactDirs,
+  resolveAuthorityStateRoot,
+  resolveAuthorityStateDir,
+  resolveAuthorityRuntimeDir,
+  resolveAuthorityRunDir,
+  resolveAuthorityProjectStateDir,
+  resolveAuthorityPaths,
+  resolveAuthorityArtifactsRoot,
+  removeAuthorityRemoteEndpoint,
+  readJsonlFile,
+  readJsonFile,
+  readAuthorityStateJson,
+  readAuthorityRun,
+  readAuthorityProjectStateJson,
+  markAuthorityRemoteEndpointConnected,
+  listAuthorityRuntimeAgentsRoots,
+  listAuthorityRuns,
+  listAuthorityRunRoots,
+  listAuthorityRemoteEndpoints,
+  listAuthorityArtifactRoots,
+  importLegacyRemoteEndpoints,
+  fileSizeIfPresent,
+  doctorAuthorityRemoteEndpoints,
+  copyFileIfPresent,
+  appendJsonlRecord
+};