nolo-cli 0.8.0 → 0.9.1

package/chunk-7OOXPE3N.js

@@ -0,0 +1,628 @@
+import {
+  buildLocalAgentLookupKeys,
+  normalizeAgentHandle,
+  shouldReadAgentKeyRemotely
+} from "./chunk-2PUGVR6E.js";
+import {
+  resolveCliAgentKeyInput
+} from "./chunk-VHBWHNVT.js";
+import {
+  readPipeText,
+  spawnProcess
+} from "./chunk-IDZTNRP2.js";
+import {
+  parseUserIdFromAuthToken,
+  readOption,
+  resolveAuthToken,
+  resolveServerCandidates,
+  resolveServerUrl
+} from "./chunk-ISNCLGUZ.js";
+import {
+  toErrorMessage
+} from "./chunk-HNMXYYJR.js";
+import {
+  createAgentKey
+} from "./chunk-SH2CFQOH.js";
+
+// packages/cli/agentRecordHelpers.ts
+import { readFileSync } from "node:fs";
+var PROVIDER_COPY_FIELDS = [
+  "apiSource",
+  "provider",
+  "cliProvider",
+  "model",
+  "customProviderUrl",
+  "apiKey",
+  "useServerProxy",
+  "inputPrice",
+  "outputPrice"
+];
+function readRepeatedOption(args, flag) {
+  const values = [];
+  for (let index = 0; index < args.length; index += 1) {
+    if (args[index] !== flag || !args[index + 1]) continue;
+    values.push(args[index + 1]);
+    index += 1;
+  }
+  return values;
+}
+function parseJsonishValue(raw) {
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return raw;
+  }
+}
+function recordHasAgentHandle(record, handle) {
+  if (!record || typeof record !== "object") return false;
+  const normalized = normalizeAgentHandle(handle);
+  if (!normalized) return false;
+  return normalizeAgentHandle(record.handle) === normalized;
+}
+async function findLocalAgentRecordByHandle(args) {
+  const normalized = normalizeAgentHandle(args.handle);
+  if (!normalized) return null;
+  try {
+    const iterator = args.db.iterator({ gte: "agent-", lte: "agent-\uFFFF" });
+    for await (const [key, record] of iterator) {
+      if (!recordHasAgentHandle(record, normalized)) continue;
+      return { key, record };
+    }
+  } catch {
+  }
+  return null;
+}
+async function findRemoteAgentRecordByHandle(args) {
+  const normalized = normalizeAgentHandle(args.handle);
+  if (!normalized) return null;
+  const records = await queryUserRecords({
+    authToken: args.authToken,
+    fallbackFetchImpl: args.fallbackFetchImpl,
+    fetchImpl: args.fetchImpl,
+    limit: 200,
+    serverUrl: args.serverUrl,
+    userId: args.userId,
+    type: "agent" /* AGENT */
+  });
+  return records.find((record) => recordHasAgentHandle(record, normalized)) ?? null;
+}
+function parsePositiveIntegerOption(raw, flag) {
+  if (!raw) return void 0;
+  const value = Number(raw);
+  if (!Number.isInteger(value) || value <= 0) {
+    throw new Error(`${flag} must be a positive integer.`);
+  }
+  return value;
+}
+function parseIsoTimestampOption(raw, flag) {
+  if (!raw) return void 0;
+  const time = Date.parse(raw);
+  if (!Number.isFinite(time)) {
+    throw new Error(`${flag} must be an ISO timestamp.`);
+  }
+  return new Date(time).toISOString();
+}
+async function curlFetch(url, init) {
+  const method = init?.method ?? "GET";
+  const headers = new Headers(init?.headers ?? {});
+  const command = ["curl", "-sS", "-L", "-X", method, "--max-time", "10"];
+  headers.forEach((value, key) => {
+    command.push("-H", `${key}: ${value}`);
+  });
+  if (typeof init?.body === "string" && init.body.length > 0) {
+    command.push("--data", init.body);
+  }
+  command.push("-w", "\n__NOLO_STATUS__:%{http_code}", url);
+  const proc = spawnProcess({ cmd: command, stdout: "pipe", stderr: "pipe" });
+  const [stdout, stderr, exitCode] = await Promise.all([
+    readPipeText(proc.stdout),
+    readPipeText(proc.stderr),
+    proc.exited
+  ]);
+  if (exitCode !== 0) {
+    throw new Error(stderr.trim() || `curl failed for ${url}`);
+  }
+  const marker = "\n__NOLO_STATUS__:";
+  const markerIndex = stdout.lastIndexOf(marker);
+  const body = markerIndex >= 0 ? stdout.slice(0, markerIndex) : stdout;
+  const statusText = markerIndex >= 0 ? stdout.slice(markerIndex + marker.length).trim() : "0";
+  const status = Number(statusText);
+  return new Response(body, {
+    status: Number.isFinite(status) ? status : 0,
+    headers: { "Content-Type": headers.get("Content-Type") ?? "application/json" }
+  });
+}
+function shouldUseCurlTransportFallback(error) {
+  const name = error instanceof Error ? error.name : "";
+  if (name === "TimeoutError" || name === "AbortError") return false;
+  const message = toErrorMessage(error);
+  if (/timed out|Timeout/i.test(message)) return false;
+  return /Unable to connect|ConnectionRefused|ECONNREFUSED|Failed to connect|Was there a typo|handshake|certificate|ECONNRESET|socket|network/i.test(message);
+}
+async function fetchWithTransportFallback(url, init, options) {
+  const signal = init.signal ?? AbortSignal.timeout(1e4);
+  const nextInit = { ...init, signal };
+  try {
+    return await options.fetchImpl(url, nextInit);
+  } catch (error) {
+    if (!shouldUseCurlTransportFallback(error)) throw error;
+    if (options.fallbackFetchImpl) {
+      return options.fallbackFetchImpl(url, nextInit);
+    }
+    if (options.fetchImpl !== fetch) throw error;
+    return curlFetch(url, nextInit);
+  }
+}
+async function readAgentRecord(args) {
+  const res = await fetchWithTransportFallback(
+    `${args.serverUrl}/api/v1/db/read/${encodeURIComponent(args.agentKey)}`,
+    {
+      method: "GET",
+      headers: { Authorization: `Bearer ${args.authToken}` }
+    },
+    args
+  );
+  const data = await res.json().catch(() => ({}));
+  if (!res.ok) {
+    throw new Error(`read failed: HTTP ${res.status} ${JSON.stringify(data)}`);
+  }
+  return data?.data ?? data;
+}
+async function readDbRecord(args) {
+  const query = args.includeDeleted ? "?includeDeleted=true" : "";
+  const res = await fetchWithTransportFallback(
+    `${args.serverUrl}/api/v1/db/read/${encodeURIComponent(args.dbKey)}${query}`,
+    {
+      method: "GET",
+      headers: { Authorization: `Bearer ${args.authToken}` }
+    },
+    args
+  );
+  const data = await res.json().catch(() => ({}));
+  if (!res.ok) {
+    throw new Error(`read failed: HTTP ${res.status} ${JSON.stringify(data)}`);
+  }
+  return data?.data ?? data;
+}
+async function queryUserRecords(args) {
+  const query = typeof args.limit === "number" && args.limit > 0 ? `?limit=${Math.floor(args.limit)}` : "";
+  const res = await fetchWithTransportFallback(
+    `${args.serverUrl}/api/v1/db/query/${encodeURIComponent(args.userId)}${query}`,
+    {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${args.authToken}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        type: args.type,
+        ...args.includeDeleted ? { includeDeleted: true } : {},
+        ...args.summary ? { summary: true } : {}
+      })
+    },
+    args
+  );
+  const data = await res.json().catch(() => ({}));
+  if (!res.ok) {
+    throw new Error(`query failed: HTTP ${res.status} ${JSON.stringify(data)}`);
+  }
+  return Array.isArray(data?.data?.data) ? data.data.data : Array.isArray(data?.data) ? data.data : [];
+}
+async function deleteDbRecord(args) {
+  const type = args.deleteOptions?.type;
+  const query = type && type !== "single" ? `?type=${encodeURIComponent(type)}` : "";
+  const res = await fetchWithTransportFallback(
+    `${args.serverUrl}/api/v1/db/delete/${encodeURIComponent(args.dbKey)}${query}`,
+    {
+      method: "DELETE",
+      headers: { Authorization: `Bearer ${args.authToken}` }
+    },
+    args
+  );
+  const data = await res.json().catch(() => ({}));
+  if (!res.ok) {
+    throw new Error(`delete failed: HTTP ${res.status} ${JSON.stringify(data)}`);
+  }
+  return data;
+}
+async function writeAgentRecord(args) {
+  const res = await fetchWithTransportFallback(`${args.serverUrl}/api/v1/db/write/`, {
+    method: "POST",
+    headers: {
+      Authorization: `Bearer ${args.authToken}`,
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify({
+      customKey: args.agentKey,
+      userId: args.userId,
+      data: {
+        ...args.record,
+        dbKey: args.agentKey
+      }
+    })
+  }, args);
+  const data = await res.json().catch(() => ({}));
+  if (!res.ok) {
+    throw new Error(`write failed: HTTP ${res.status} ${JSON.stringify(data)}`);
+  }
+}
+async function resolveAgentRecordFromHybridStore(args) {
+  const agentKey = resolveCliAgentKeyInput(args.agentInput);
+  const authToken = args.cliArgs ? resolveAuthToken(args.cliArgs, args.env) : resolveAuthToken(args.env);
+  const defaultServerUrl = args.cliArgs ? resolveServerUrl(args.cliArgs, args.env) : resolveServerUrl(args.env);
+  const userId = parseUserIdFromAuthToken(authToken) || "local";
+  for (const key of buildLocalAgentLookupKeys({
+    agentRef: agentKey,
+    userId
+  })) {
+    try {
+      const record = await args.db.get(key);
+      if (record && typeof record === "object") {
+        const cacheAge = Date.now() - (Number(record?.cachedAt) || 0);
+        const STALE_CACHE_MS = 6e4;
+        if (record?.serverOrigin && shouldReadAgentKeyRemotely(key) && cacheAge > STALE_CACHE_MS) {
+          try {
+            await readAgentRecord({
+              agentKey: key,
+              authToken,
+              fallbackFetchImpl: args.fallbackFetchImpl,
+              fetchImpl: args.fetchImpl,
+              serverUrl: record.serverOrigin
+            });
+            try {
+              await args.db.put(key, { ...record, cachedAt: Date.now() });
+            } catch {
+            }
+          } catch (err) {
+            const msg = toErrorMessage(err);
+            if (msg.includes("HTTP 404")) {
+              try {
+                await args.db.del(key);
+              } catch {
+              }
+              continue;
+            }
+          }
+        }
+        return {
+          agentKey: key,
+          record,
+          source: record?.serverOrigin ? "remote-cache" : "local-cache"
+        };
+      }
+    } catch {
+    }
+    if (!shouldReadAgentKeyRemotely(key)) continue;
+    for (const serverUrl of args.cliArgs ? resolveServerCandidates(args.cliArgs, args.env, defaultServerUrl) : resolveServerCandidates(args.env, defaultServerUrl)) {
+      try {
+        const remoteRecord = await readAgentRecord({
+          agentKey: key,
+          authToken,
+          fallbackFetchImpl: args.fallbackFetchImpl,
+          fetchImpl: args.fetchImpl,
+          serverUrl
+        });
+        const cached = { ...remoteRecord, dbKey: key, serverOrigin: serverUrl, cachedAt: Date.now() };
+        await args.db.put(key, cached);
+        return {
+          agentKey: key,
+          record: cached,
+          source: "remote-cache"
+        };
+      } catch {
+      }
+    }
+  }
+  const localHandleRecord = await findLocalAgentRecordByHandle({
+    handle: args.agentInput,
+    db: args.db
+  });
+  if (localHandleRecord) {
+    return {
+      agentKey: localHandleRecord.key,
+      record: localHandleRecord.record,
+      source: localHandleRecord.record?.serverOrigin ? "remote-cache" : "local-cache"
+    };
+  }
+  if (authToken && userId !== "local") {
+    for (const serverUrl of args.cliArgs ? resolveServerCandidates(args.cliArgs, args.env, defaultServerUrl) : resolveServerCandidates(args.env, defaultServerUrl)) {
+      try {
+        const remoteRecord = await findRemoteAgentRecordByHandle({
+          handle: args.agentInput,
+          authToken,
+          fallbackFetchImpl: args.fallbackFetchImpl,
+          fetchImpl: args.fetchImpl,
+          serverUrl,
+          userId
+        });
+        if (!remoteRecord || typeof remoteRecord !== "object") continue;
+        const key = typeof remoteRecord.dbKey === "string" && remoteRecord.dbKey ? remoteRecord.dbKey : typeof remoteRecord.key === "string" && remoteRecord.key ? remoteRecord.key : "";
+        if (!key) continue;
+        const cached = { ...remoteRecord, dbKey: key, serverOrigin: serverUrl };
+        await args.db.put(key, cached);
+        return {
+          agentKey: key,
+          record: cached,
+          source: "remote-cache"
+        };
+      } catch {
+      }
+    }
+  }
+  return null;
+}
+var CLI_SECRET_FIELD_NAMES = /* @__PURE__ */ new Set([
+  "apikey",
+  "password",
+  "passwd",
+  "secret",
+  "clientsecret",
+  "accesstoken",
+  "refreshtoken",
+  "sessiontoken",
+  "bearertoken",
+  "authorization",
+  "authheader",
+  "token",
+  "oauthtoken",
+  "idtoken",
+  "credentials",
+  "credential"
+]);
+var CLI_CREDENTIAL_REF_FIELDS = /* @__PURE__ */ new Set(["credentialref", "apikeyref"]);
+var normalizeCredentialFieldName = (value) => value.replace(/[^a-z0-9]/gi, "").toLowerCase();
+function isNonEmptyCredentialValue(value) {
+  if (value == null) return false;
+  if (typeof value === "string") return value.trim().length > 0;
+  if (typeof value === "object") return Object.keys(value).length > 0;
+  return true;
+}
+function agentRecordHasConfiguredCredential(record) {
+  if (!record || typeof record !== "object") return false;
+  if (Array.isArray(record)) {
+    return record.some(agentRecordHasConfiguredCredential);
+  }
+  for (const [key, value] of Object.entries(record)) {
+    const normalizedKey = normalizeCredentialFieldName(key);
+    if ((CLI_SECRET_FIELD_NAMES.has(normalizedKey) || CLI_CREDENTIAL_REF_FIELDS.has(normalizedKey)) && isNonEmptyCredentialValue(value)) {
+      return true;
+    }
+    if (typeof value === "object" && value != null && agentRecordHasConfiguredCredential(value)) {
+      return true;
+    }
+  }
+  return false;
+}
+function sanitizeAgentRecordForCliOutput(record) {
+  if (record == null || typeof record !== "object") return record;
+  if (Array.isArray(record)) {
+    return record.map((item) => sanitizeAgentRecordForCliOutput(item));
+  }
+  const source = record;
+  const out = {};
+  for (const [key, value] of Object.entries(source)) {
+    const normalizedKey = normalizeCredentialFieldName(key);
+    if (CLI_SECRET_FIELD_NAMES.has(normalizedKey)) continue;
+    if (CLI_CREDENTIAL_REF_FIELDS.has(normalizedKey)) {
+      if (isNonEmptyCredentialValue(value)) out[key] = value;
+      continue;
+    }
+    if (value != null && typeof value === "object") {
+      out[key] = sanitizeAgentRecordForCliOutput(value);
+      continue;
+    }
+    out[key] = value;
+  }
+  return out;
+}
+function normalizeAgentRecordForOutput(agentKey, authToken, agent) {
+  const credentialConfigured = agentRecordHasConfiguredCredential(agent);
+  const sanitizedRecord = sanitizeAgentRecordForCliOutput(agent);
+  return {
+    agentKey,
+    baseUrl: agent?.serverOrigin ?? null,
+    name: agent?.name,
+    greeting: agent?.greeting,
+    model: agent?.model,
+    provider: agent?.provider ?? agent?.apiSource ?? null,
+    cliProvider: agent?.cliProvider ?? null,
+    customProviderUrl: agent?.customProviderUrl ?? null,
+    tools: agent?.tools ?? [],
+    isPublic: agent?.isPublic,
+    credentialConfigured,
+    credentialRef: agent?.credentialRef ?? void 0,
+    apiKeyRef: agent?.apiKeyRef ?? void 0,
+    authUserId: parseUserIdFromAuthToken(authToken),
+    userId: agent?.userId,
+    record: sanitizedRecord
+  };
+}
+function parseAgentUpdateArgs(args) {
+  const agentInput = readOption(args, "--agent") ?? readOption(args, "--id") ?? args[0]?.trim();
+  if (!agentInput || agentInput === "--help" || agentInput === "-h") return null;
+  const updates = {};
+  const model = readOption(args, "--model");
+  const cliProvider = readOption(args, "--cli-provider");
+  const apiSource = readOption(args, "--api-source");
+  const provider = readOption(args, "--provider");
+  const prompt = readOption(args, "--prompt");
+  const promptFile = readOption(args, "--prompt-file");
+  const promptDoc = readOption(args, "--prompt-doc");
+  const tools = readOption(args, "--tools");
+  const copyProviderFrom = readOption(args, "--copy-provider-from");
+  const name = readOption(args, "--name");
+  const customProviderUrl = readOption(args, "--custom-provider-url");
+  const apiKey = readOption(args, "--api-key");
+  const maxConcurrent = parsePositiveIntegerOption(
+    readOption(args, "--max-concurrent"),
+    "--max-concurrent"
+  );
+  const expiresAt = parseIsoTimestampOption(readOption(args, "--expires-at"), "--expires-at");
+  const handle = readOption(args, "--handle")?.trim();
+  const promptSources = [prompt, promptFile, promptDoc].filter(Boolean);
+  if (promptSources.length > 1) {
+    throw new Error("--prompt / --prompt-file / --prompt-doc are mutually exclusive.");
+  }
+  if (model) updates.model = model;
+  if (cliProvider) updates.cliProvider = cliProvider;
+  if (apiSource) updates.apiSource = apiSource;
+  if (provider) updates.provider = provider;
+  if (prompt) updates.prompt = prompt;
+  if (promptFile) updates.prompt = readFileSync(promptFile, "utf8");
+  if (tools) updates.tools = parseJsonishValue(tools);
+  if (name) updates.name = name;
+  if (customProviderUrl) updates.customProviderUrl = customProviderUrl;
+  if (apiKey) updates.apiKey = apiKey;
+  if (maxConcurrent != null) updates.admission = { maxConcurrent };
+  if (expiresAt) {
+    updates.scheduling = { expiresAt };
+  }
+  if (handle) updates.handle = handle;
+  for (const entry of readRepeatedOption(args, "--field")) {
+    const index = entry.indexOf("=");
+    if (index <= 0) {
+      throw new Error(`--field must use key=value, received ${JSON.stringify(entry)}`);
+    }
+    updates[entry.slice(0, index)] = parseJsonishValue(entry.slice(index + 1));
+  }
+  if (Object.keys(updates).length === 0) {
+    if (!promptDoc && !copyProviderFrom) {
+      throw new Error("No updates provided. Use --model / --cli-provider / --api-source / --field key=value.");
+    }
+  }
+  return { agentInput, updates, promptDoc, copyProviderFrom };
+}
+async function buildCreatedAgentRecord(args) {
+  const serverUrl = args.cliArgs ? resolveServerUrl(args.cliArgs, args.env) : resolveServerUrl(args.env);
+  const userId = parseUserIdFromAuthToken(args.authToken);
+  const resolvedAgentInput = resolveCliAgentKeyInput(args.parsed.agentInput);
+  const agentKey = resolvedAgentInput.startsWith("agent-") ? resolvedAgentInput : createAgentKey.private(userId || "local", resolvedAgentInput);
+  if (args.parsed.copyProviderFrom) {
+    const providerSource = await resolveAgentRecordFromHybridStore({
+      agentInput: args.parsed.copyProviderFrom,
+      cliArgs: args.cliArgs,
+      env: args.env,
+      db: args.db,
+      fetchImpl: args.fetchImpl,
+      fallbackFetchImpl: args.fallbackFetchImpl
+    });
+    if (!providerSource) {
+      throw new Error(`provider source agent not found: ${args.parsed.copyProviderFrom}`);
+    }
+    for (const field of PROVIDER_COPY_FIELDS) {
+      if (field in providerSource.record) {
+        args.parsed.updates[field] = providerSource.record[field];
+      }
+    }
+  }
+  if (args.parsed.promptDoc) {
+    const promptDoc = await readDbRecord({
+      dbKey: args.parsed.promptDoc,
+      authToken: args.authToken,
+      fallbackFetchImpl: args.fallbackFetchImpl,
+      fetchImpl: args.fetchImpl,
+      serverUrl
+    });
+    const promptBody = typeof promptDoc?.content === "string" ? promptDoc.content : "";
+    if (!promptBody.trim()) {
+      throw new Error(`prompt doc is empty or unreadable: ${args.parsed.promptDoc}`);
+    }
+    args.parsed.updates.prompt = promptBody;
+  }
+  const nextRecord = {
+    ...args.parsed.updates,
+    dbKey: agentKey,
+    key: agentKey,
+    type: "agent" /* AGENT */,
+    createdAt: Date.now(),
+    updatedAt: Date.now(),
+    userId
+  };
+  return {
+    agentKey,
+    serverUrl,
+    nextRecord,
+    updates: args.parsed.updates
+  };
+}
+async function buildUpdatedAgentRecord(args) {
+  const cached = await resolveAgentRecordFromHybridStore({
+    agentInput: args.parsed.agentInput,
+    cliArgs: args.cliArgs,
+    env: args.env,
+    db: args.db,
+    fetchImpl: args.fetchImpl,
+    fallbackFetchImpl: args.fallbackFetchImpl
+  });
+  const agentKey = cached?.agentKey ?? resolveCliAgentKeyInput(args.parsed.agentInput);
+  const explicitServerUrl = args.cliArgs ? readOption(args.cliArgs, "--server-url") || readOption(args.cliArgs, "--server") : void 0;
+  const envServerUrl = args.env.NOLO_SERVER || args.env.BASE_URL || args.env.NOLO_SERVER_URL;
+  const requestedServerUrl = explicitServerUrl || envServerUrl ? args.cliArgs ? resolveServerUrl(args.cliArgs, args.env) : resolveServerUrl(args.env) : void 0;
+  const serverUrl = requestedServerUrl || cached?.record?.serverOrigin || resolveServerUrl(args.env);
+  const currentRecord = await readAgentRecord({
+    agentKey,
+    authToken: args.authToken,
+    fallbackFetchImpl: args.fallbackFetchImpl,
+    fetchImpl: args.fetchImpl,
+    serverUrl
+  });
+  if (args.parsed.copyProviderFrom) {
+    const providerSource = await resolveAgentRecordFromHybridStore({
+      agentInput: args.parsed.copyProviderFrom,
+      cliArgs: args.cliArgs,
+      env: args.env,
+      db: args.db,
+      fetchImpl: args.fetchImpl,
+      fallbackFetchImpl: args.fallbackFetchImpl
+    });
+    if (!providerSource) {
+      throw new Error(`provider source agent not found: ${args.parsed.copyProviderFrom}`);
+    }
+    for (const field of PROVIDER_COPY_FIELDS) {
+      if (field in providerSource.record) {
+        args.parsed.updates[field] = providerSource.record[field];
+      }
+    }
+  }
+  if (args.parsed.promptDoc) {
+    const promptDoc = await readDbRecord({
+      dbKey: args.parsed.promptDoc,
+      authToken: args.authToken,
+      fallbackFetchImpl: args.fallbackFetchImpl,
+      fetchImpl: args.fetchImpl,
+      serverUrl
+    });
+    const promptBody = typeof promptDoc?.content === "string" ? promptDoc.content : "";
+    if (!promptBody.trim()) {
+      throw new Error(`prompt doc is empty or unreadable: ${args.parsed.promptDoc}`);
+    }
+    args.parsed.updates.prompt = promptBody;
+  }
+  const nextRecord = {
+    ...currentRecord,
+    ...args.parsed.updates,
+    updatedAt: Date.now()
+  };
+  return {
+    agentKey,
+    serverUrl,
+    nextRecord,
+    updates: args.parsed.updates
+  };
+}
+
+export {
+  fetchWithTransportFallback,
+  readAgentRecord,
+  readDbRecord,
+  queryUserRecords,
+  deleteDbRecord,
+  writeAgentRecord,
+  resolveAgentRecordFromHybridStore,
+  agentRecordHasConfiguredCredential,
+  sanitizeAgentRecordForCliOutput,
+  normalizeAgentRecordForOutput,
+  parseAgentUpdateArgs,
+  buildCreatedAgentRecord,
+  buildUpdatedAgentRecord
+};