@sixb/cli-core 0.1.4

package/src/commands/objects.ts

@@ -0,0 +1,291 @@
+import type { ApiClient } from "../api-client"
+import {
+  enumValue,
+  integerInRange,
+  isHelp,
+  parseCommandArgs,
+  requestsHelp,
+  requireOrderedRange,
+  rfc3339Value,
+} from "../arguments"
+import { inspectGraph } from "../graph"
+import { fail, writeJson, writeText } from "../output"
+import { CLI_LIMITS, DEFAULT_LIST_ORDER, DEFAULT_OBJECT_ORDER_BY } from "../policies"
+import { FACETS_EXAMPLE, OBJECTS_HELP, QUERY_EXAMPLES, QUERY_HELP } from "./metadata"
+import {
+  asRecord,
+  normalizeWindowOptions,
+  parseQueryOptions,
+  readJson,
+  singleFileOption,
+} from "./shared"
+
+export async function objects(api: ApiClient, args: readonly string[]): Promise<void> {
+  const [sub, ...rest] = args
+  if (!sub || isHelp(sub)) return writeText(OBJECTS_HELP)
+  switch (sub) {
+    case "inspect":
+      return objectsInspect(api, rest)
+    case "list":
+      return objectsList(api, rest)
+    case "get":
+      return objectsGet(api, rest)
+    case "search":
+      return objectsSearch(api, rest)
+    case "query":
+      return objectsQuery(api, rest)
+    case "count":
+    case "exists":
+      return objectsScalar(api, sub, rest)
+    case "facets":
+      return objectsFacets(api, rest)
+    case "links":
+      return objectsLinks(api, rest)
+    default:
+      fail(`Unknown objects command '${sub}'.`)
+  }
+}
+
+async function objectsInspect(api: ApiClient, args: readonly string[]): Promise<void> {
+  if (requestsHelp(args)) return writeText(OBJECTS_HELP)
+  const { positionals, options } = parseCommandArgs(
+    args,
+    {
+      "--full": "boolean",
+      "--depth": "string",
+      "--max-objects": "string",
+      "--max-links": "string",
+    },
+    "objects inspect",
+    2
+  )
+  const objectTypeId = positionals[0] ?? ""
+  const primaryId = positionals[1] ?? ""
+  const depth = integerInRange(
+    "--depth",
+    options["--depth"] ?? String(CLI_LIMITS.inspect.depth.default),
+    0,
+    CLI_LIMITS.inspect.depth.maximum
+  )
+  const maxObjects = integerInRange(
+    "--max-objects",
+    options["--max-objects"] ?? String(CLI_LIMITS.inspect.objects.default),
+    1,
+    CLI_LIMITS.inspect.objects.maximum
+  )
+  const maxLinks = integerInRange(
+    "--max-links",
+    options["--max-links"] ?? String(CLI_LIMITS.inspect.links.default),
+    1,
+    CLI_LIMITS.inspect.links.maximum
+  )
+  const full = options["--full"] ?? false
+  writeJson(
+    await inspectGraph(api, objectTypeId, primaryId, {
+      depth,
+      maxObjects,
+      maxLinks,
+      full,
+    })
+  )
+}
+
+async function objectsList(api: ApiClient, args: readonly string[]): Promise<void> {
+  if (requestsHelp(args)) return writeText(OBJECTS_HELP)
+  const optionNames: Record<string, string> = {
+    "--type": "objectTypeId",
+    "--limit": "limit",
+    "--offset": "offset",
+    "--order-by": "orderBy",
+    "--order": "order",
+    "--id-prefix": "idPrefix",
+    "--id-suffix": "idSuffix",
+    "--created-after": "createdAfter",
+    "--created-before": "createdBefore",
+    "--updated-after": "updatedAfter",
+    "--updated-before": "updatedBefore",
+  }
+  const options = normalizeWindowOptions(parseQueryOptions(args, optionNames, "objects list"), {
+    defaultLimit: CLI_LIMITS.list.default,
+    maximumLimit: CLI_LIMITS.list.maximum,
+    defaultOrder: DEFAULT_LIST_ORDER,
+    offset: true,
+  })
+  options.orderBy = enumValue("--order-by", options.orderBy ?? DEFAULT_OBJECT_ORDER_BY, [
+    "createdAt",
+    "updatedAt",
+    "primaryId",
+  ])
+  for (const [name, flag] of [
+    ["createdAfter", "--created-after"],
+    ["createdBefore", "--created-before"],
+    ["updatedAfter", "--updated-after"],
+    ["updatedBefore", "--updated-before"],
+  ] as const) {
+    if (options[name] !== undefined) options[name] = rfc3339Value(flag, options[name])
+  }
+  requireOrderedRange(
+    "--created-after",
+    options.createdAfter,
+    "--created-before",
+    options.createdBefore
+  )
+  requireOrderedRange(
+    "--updated-after",
+    options.updatedAfter,
+    "--updated-before",
+    options.updatedBefore
+  )
+  writeJson(await api.get("/api/objects", options))
+}
+
+async function objectsGet(api: ApiClient, args: readonly string[]): Promise<void> {
+  if (requestsHelp(args)) return writeText("Usage: sixb objects get <object-type> <primary-id>...")
+  const { positionals } = parseCommandArgs(args, {}, "objects get", [2, Number.POSITIVE_INFINITY])
+  const objectTypeId = positionals[0] ?? ""
+  writeJson(
+    await api.post("/api/objects/query", {
+      query: {
+        kind: "refs",
+        refs: positionals.slice(1).map((primaryId) => ({ objectTypeId, primaryId })),
+      },
+      includeTotal: false,
+    })
+  )
+}
+
+async function objectsSearch(api: ApiClient, args: readonly string[]): Promise<void> {
+  if (requestsHelp(args)) {
+    return writeText(`Usage: sixb objects search <text> [--limit <1-${CLI_LIMITS.search.maximum}>]`)
+  }
+  const { positionals, options } = parseCommandArgs(
+    args,
+    { "--limit": "string" },
+    "objects search",
+    1
+  )
+  const limit = String(
+    integerInRange(
+      "--limit",
+      options["--limit"] ?? String(CLI_LIMITS.search.default),
+      1,
+      CLI_LIMITS.search.maximum
+    )
+  )
+  writeJson(await api.get("/api/objects/search", { q: positionals[0], limit }))
+}
+
+async function objectsQuery(api: ApiClient, args: readonly string[]): Promise<void> {
+  if (requestsHelp(args)) return writeText(QUERY_HELP)
+  const { options } = parseCommandArgs(
+    args,
+    {
+      "--example": "string",
+      "--file": "string",
+      "--include-total": "boolean",
+      "--no-total": "boolean",
+    },
+    "objects query"
+  )
+  if (options["--include-total"] && options["--no-total"])
+    fail("--include-total and --no-total cannot be used together.")
+  if (options["--example"]) {
+    if (Object.keys(options).length !== 1) fail("--example cannot be combined with query options.")
+    const name = options["--example"]
+    if (name === "list") return writeText(Object.keys(QUERY_EXAMPLES).join(" "))
+    const example = QUERY_EXAMPLES[name]
+    if (!example) fail(`Unknown query example '${name}'. Run 'sixb objects query --example list'.`)
+    return writeText(example)
+  }
+  const source = options["--file"]
+  const includeTotal = options["--include-total"] ?? false
+  if (!source) fail("objects query requires --file <path|->.")
+  const input = await readJson(source)
+  const record = asRecord(input)
+  const body = Object.hasOwn(record, "query")
+    ? { ...record, ...(Object.hasOwn(record, "includeTotal") ? {} : { includeTotal }) }
+    : { query: input, includeTotal }
+  writeJson(await api.post("/api/objects/query", body))
+}
+
+async function objectsScalar(
+  api: ApiClient,
+  operation: "count" | "exists",
+  args: readonly string[]
+): Promise<void> {
+  if (requestsHelp(args)) return writeText(`Usage: sixb objects ${operation} --file <path|->`)
+  const source = singleFileOption(args, `objects ${operation}`)
+  const input = await readJson(source)
+  const record = asRecord(input)
+  writeJson(
+    await api.post(`/api/objects/query/${operation}`, {
+      query: Object.hasOwn(record, "query") ? record.query : input,
+    })
+  )
+}
+
+async function objectsFacets(api: ApiClient, args: readonly string[]): Promise<void> {
+  if (requestsHelp(args)) {
+    return writeText(
+      "Usage: sixb objects facets --file <path|->\n       sixb objects facets --example"
+    )
+  }
+  const { options } = parseCommandArgs(
+    args,
+    { "--file": "string", "--example": "boolean" },
+    "objects facets"
+  )
+  if (options["--example"]) {
+    if (options["--file"]) fail("--example cannot be combined with --file.")
+    return writeText(FACETS_EXAMPLE)
+  }
+  if (!options["--file"]) fail("objects facets requires --file <path|->.")
+  const body = await readJson(options["--file"])
+  const record = asRecord(body)
+  if (!Object.hasOwn(record, "query") || !Object.hasOwn(record, "facets")) {
+    fail("objects facets input must contain query and facets.")
+  }
+  writeJson(await api.post("/api/objects/query/facets", body))
+}
+
+async function objectsLinks(api: ApiClient, args: readonly string[]): Promise<void> {
+  if (requestsHelp(args)) return writeText(OBJECTS_HELP)
+  const { positionals, options } = parseCommandArgs(
+    args,
+    {
+      "--link": "string",
+      "--direction": "string",
+      "--page-size": "string",
+      "--page-token": "string",
+      "--include-objects": "boolean",
+    },
+    "objects links",
+    2
+  )
+  const objectTypeId = positionals[0] ?? ""
+  const primaryId = positionals[1] ?? ""
+  const linkId = options["--link"]
+  const direction = enumValue("--direction", options["--direction"] ?? "both", [
+    "outgoing",
+    "incoming",
+    "both",
+  ])
+  const pageSize = integerInRange(
+    "--page-size",
+    options["--page-size"] ?? String(CLI_LIMITS.linkPage.default),
+    1,
+    CLI_LIMITS.linkPage.maximum
+  )
+  const pageToken = options["--page-token"]
+  const includeObjects = options["--include-objects"] ?? false
+  writeJson(
+    await api.post("/api/objects/query/links", {
+      query: { kind: "refs", refs: [{ objectTypeId, primaryId }] },
+      direction,
+      includeObjects,
+      pageSize,
+      ...(linkId ? { linkId } : {}),
+      ...(pageToken ? { pageToken } : {}),
+    })
+  )
+}

package/src/commands/ontology.ts

@@ -0,0 +1,50 @@
+import type { ApiClient } from "../api-client"
+import { isHelp, parseCommandArgs, requestsHelp } from "../arguments"
+import { fail, writeJson, writeText } from "../output"
+import { GROUP_HELP } from "./metadata"
+import { asRecord, asRecords } from "./shared"
+
+export async function ontology(api: ApiClient, args: readonly string[]): Promise<void> {
+  const [sub, ...rest] = args
+  if (!sub || isHelp(sub)) return writeText(GROUP_HELP.ontology)
+  if (sub === "list") {
+    if (requestsHelp(rest)) return writeText("Usage: sixb ontology list [--full]")
+    const { options } = parseCommandArgs(rest, { "--full": "boolean" }, "ontology list")
+    const full = options["--full"] ?? false
+    const value = await api.get("/api/object-types")
+    if (full) return writeJson(value)
+    if (!Array.isArray(value)) fail("The ontology API returned an invalid response.")
+    return writeJson(
+      value.map((entry) => {
+        const type = asRecord(entry)
+        const properties = asRecords(type.properties)
+        return {
+          id: type.id,
+          name: type.name,
+          description: type.description,
+          primaryPropertyId: properties.find((property) => property.primary === true)?.id,
+          links: asRecords(type.links).map(
+            ({ id, name, description, targetObjectTypeId, cardinality }) => ({
+              id,
+              name,
+              ...(description === undefined ? {} : { description }),
+              targetObjectTypeId,
+              cardinality,
+            })
+          ),
+          actions: asRecords(type.actions).map(({ id, name, description }) => ({
+            id,
+            name,
+            ...(description === undefined ? {} : { description }),
+          })),
+        }
+      })
+    )
+  }
+  if (sub === "get") {
+    if (requestsHelp(rest)) return writeText("Usage: sixb ontology get <object-type>")
+    const { positionals } = parseCommandArgs(rest, {}, "ontology get", 1)
+    return writeJson(await api.get(`/api/object-types/${encodeURIComponent(positionals[0] ?? "")}`))
+  }
+  fail(`Unknown ontology command '${sub}'.`)
+}

package/src/commands/project.ts

@@ -0,0 +1,13 @@
+import type { ApiClient } from "../api-client"
+import { isHelp, parseCommandArgs, requestsHelp } from "../arguments"
+import { fail, writeJson, writeText } from "../output"
+import { GROUP_HELP } from "./metadata"
+
+export async function project(api: ApiClient, args: readonly string[]): Promise<void> {
+  if (!args[0] || isHelp(args[0]) || (args[0] === "show" && requestsHelp(args.slice(1)))) {
+    return writeText(GROUP_HELP.project)
+  }
+  if (args[0] !== "show") fail(`Unknown project command '${args[0]}'.`)
+  parseCommandArgs(args.slice(1), {}, "project show")
+  writeJson(await api.get("/api/project"))
+}

package/src/commands/runs.ts

@@ -0,0 +1,84 @@
+import type { ApiClient } from "../api-client"
+import {
+  enumValue,
+  isHelp,
+  parseCommandArgs,
+  requestsHelp,
+  requireOrderedRange,
+  rfc3339Value,
+} from "../arguments"
+import { fail, writeJson, writeText } from "../output"
+import { CLI_LIMITS, DEFAULT_LIST_ORDER } from "../policies"
+import { GROUP_HELP } from "./metadata"
+import { normalizeWindowOptions, parseQueryOptions } from "./shared"
+
+const ACTION_RUN_STATUSES = ["queued", "running", "succeeded", "failed", "cancelled"] as const
+const WORKFLOW_RUN_STATUSES = [
+  "queued",
+  "running",
+  "waiting",
+  "succeeded",
+  "failed",
+  "cancelled",
+] as const
+
+export async function runs(
+  api: ApiClient,
+  kind: "action" | "workflow",
+  args: readonly string[]
+): Promise<void> {
+  const [sub, ...rest] = args
+  const group = `${kind}-runs` as "action-runs" | "workflow-runs"
+  if (!sub || isHelp(sub) || requestsHelp(rest)) return writeText(GROUP_HELP[group])
+  if (sub === "get") {
+    const { positionals } = parseCommandArgs(rest, {}, `${group} get`, 1)
+    return writeJson(await api.get(`/api/${group}/${encodeURIComponent(positionals[0] ?? "")}`))
+  }
+  if (sub === "list") {
+    const common = {
+      "--status": "status",
+      "--started-after": "startedAfter",
+      "--started-before": "startedBefore",
+      "--limit": "limit",
+      "--offset": "offset",
+      "--order": "order",
+    }
+    const action = {
+      ...common,
+      "--action": "actionId",
+      "--type": "objectTypeId",
+      "--id": "primaryId",
+    }
+    const workflow = { ...common, "--workflow": "workflowId" }
+    const options = normalizeWindowOptions(
+      parseQueryOptions(rest, kind === "action" ? action : workflow, `${group} list`),
+      {
+        defaultLimit: CLI_LIMITS.list.default,
+        maximumLimit: CLI_LIMITS.list.maximum,
+        defaultOrder: DEFAULT_LIST_ORDER,
+        offset: true,
+      }
+    )
+    if (options.status !== undefined) {
+      options.status = enumValue(
+        "--status",
+        options.status,
+        kind === "action" ? ACTION_RUN_STATUSES : WORKFLOW_RUN_STATUSES
+      )
+    }
+    for (const [name, flag] of [
+      ["startedAfter", "--started-after"],
+      ["startedBefore", "--started-before"],
+    ] as const) {
+      if (options[name] !== undefined) options[name] = rfc3339Value(flag, options[name])
+    }
+    requireOrderedRange(
+      "--started-after",
+      options.startedAfter,
+      "--started-before",
+      options.startedBefore
+    )
+    return writeJson(await api.get(`/api/${group}`, options))
+  }
+  fail(`Unknown ${group} command '${sub}'.`)
+}

package/src/commands/shared.ts

@@ -0,0 +1,97 @@
+import { readFile } from "node:fs/promises"
+import { enumValue, integerInRange, nonNegativeInteger, parseCommandArgs } from "../arguments"
+import { fail } from "../output"
+
+export type QueryOptions = Record<string, string | undefined>
+
+/** Parse flag/value pairs into API query parameters. */
+
+export function parseQueryOptions(
+  args: readonly string[],
+  names: Readonly<Record<string, string>>,
+  command: string
+): QueryOptions {
+  const kinds = Object.fromEntries(Object.keys(names).map((flag) => [flag, "string" as const]))
+  const { options } = parseCommandArgs(args, kinds, command)
+  const query: QueryOptions = {}
+  for (const [flag, value] of Object.entries(options)) {
+    const name = names[flag]
+    if (name) query[name] = value
+  }
+  return query
+}
+
+export function normalizeWindowOptions(
+  options: QueryOptions,
+  policy: {
+    readonly defaultLimit: number
+    readonly maximumLimit: number
+    readonly defaultOrder: "asc" | "desc"
+    readonly offset?: boolean
+  }
+): QueryOptions {
+  const normalized: QueryOptions = {
+    ...options,
+    limit: String(
+      integerInRange(
+        "--limit",
+        options.limit ?? String(policy.defaultLimit),
+        1,
+        policy.maximumLimit
+      )
+    ),
+    order: enumValue("--order", options.order ?? policy.defaultOrder, ["asc", "desc"]),
+  }
+  if (policy.offset && options.offset !== undefined) {
+    normalized.offset = String(nonNegativeInteger("--offset", options.offset))
+  }
+  return normalized
+}
+
+export function singleFileOption(args: readonly string[], command: string): string {
+  const { options } = parseCommandArgs(args, { "--file": "string" }, command)
+  if (!options["--file"]) fail(`${command} requires --file <path|->.`)
+  return options["--file"]
+}
+
+export async function readJson(source: string): Promise<unknown> {
+  let text: string
+  try {
+    text = source === "-" ? await readStdin() : await readFile(source, "utf8")
+  } catch (error) {
+    if (isFileError(error, "ENOENT")) fail(`JSON file '${source}' does not exist.`)
+    throw error
+  }
+  try {
+    return JSON.parse(text)
+  } catch {
+    fail(
+      source === "-"
+        ? "Standard input is not valid JSON."
+        : `JSON file '${source}' is not valid JSON.`,
+      "invalid_json"
+    )
+  }
+}
+
+export function asRecord(value: unknown): Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value)
+    ? (value as Record<string, unknown>)
+    : {}
+}
+
+export function asRecords(value: unknown): Record<string, unknown>[] {
+  return Array.isArray(value) ? value.map(asRecord) : []
+}
+
+export function isFileError(error: unknown, code: string): error is NodeJS.ErrnoException {
+  return error instanceof Error && "code" in error && error.code === code
+}
+
+async function readStdin(): Promise<string> {
+  const chunks: Uint8Array[] = []
+  for await (const chunk of process.stdin) {
+    chunks.push(typeof chunk === "string" ? new TextEncoder().encode(chunk) : chunk)
+  }
+  return new TextDecoder().decode(Buffer.concat(chunks))
+}

package/src/commands/telemetry.ts

@@ -0,0 +1,96 @@
+import type { ApiClient } from "../api-client"
+import {
+  enumValue,
+  integerInRange,
+  isHelp,
+  parseCommandArgs,
+  requestsHelp,
+  requireOrderedRange,
+  rfc3339Value,
+} from "../arguments"
+import { fail, writeJson, writeText } from "../output"
+import { CLI_LIMITS, DEFAULT_TELEMETRY_ORDER } from "../policies"
+import { GROUP_HELP } from "./metadata"
+import { normalizeWindowOptions, readJson, singleFileOption } from "./shared"
+
+export async function telemetry(api: ApiClient, args: readonly string[]): Promise<void> {
+  const [sub, ...rest] = args
+  if (!sub || isHelp(sub) || requestsHelp(rest)) return writeText(GROUP_HELP.telemetry)
+  if (sub === "latest") {
+    const { positionals } = parseCommandArgs(rest, {}, "telemetry latest", 3)
+    return writeJson(await api.get(telemetryPath(positionals, "latest")))
+  }
+  if (sub === "history") {
+    const { positionals, options } = parseCommandArgs(
+      rest,
+      {
+        "--from": "string",
+        "--to": "string",
+        "--limit": "string",
+        "--order": "string",
+      },
+      "telemetry history",
+      3
+    )
+    const query = normalizeWindowOptions(
+      {
+        from: options["--from"],
+        to: options["--to"],
+        limit: options["--limit"],
+        order: options["--order"],
+      },
+      {
+        defaultLimit: CLI_LIMITS.telemetryHistory.default,
+        maximumLimit: CLI_LIMITS.telemetryHistory.maximum,
+        defaultOrder: DEFAULT_TELEMETRY_ORDER,
+      }
+    )
+    if (query.from !== undefined) query.from = rfc3339Value("--from", query.from)
+    if (query.to !== undefined) query.to = rfc3339Value("--to", query.to)
+    requireOrderedRange("--from", query.from, "--to", query.to)
+    return writeJson(await api.get(telemetryPath(positionals, "history"), query))
+  }
+  if (sub === "query") {
+    return writeJson(
+      await api.post(
+        "/api/telemetry/history",
+        normalizeTelemetryQueryInput(await readJson(singleFileOption(rest, "telemetry query")))
+      )
+    )
+  }
+  fail(`Unknown telemetry command '${sub}'.`)
+}
+
+function telemetryPath(args: readonly string[], terminal: "latest" | "history"): string {
+  return `/api/objects/${encodeURIComponent(args[0] ?? "")}/${encodeURIComponent(args[1] ?? "")}/telemetry/${encodeURIComponent(args[2] ?? "")}/${terminal}`
+}
+
+function normalizeTelemetryQueryInput(input: unknown): Record<string, unknown> {
+  if (Array.isArray(input) || typeof input !== "object" || input === null) {
+    fail("Telemetry query input must be a JSON object.")
+  }
+  const body = { ...input } as Record<string, unknown>
+  const rawLimit = body.limitPerSeries
+  if (rawLimit !== undefined && typeof rawLimit !== "number") {
+    fail("limitPerSeries must be a number.")
+  }
+  body.limitPerSeries = integerInRange(
+    "limitPerSeries",
+    String(rawLimit ?? CLI_LIMITS.telemetryHistory.default),
+    1,
+    CLI_LIMITS.telemetryHistory.maximum
+  )
+  const rawOrder = body.order
+  if (rawOrder !== undefined && typeof rawOrder !== "string") {
+    fail("order must be a string.")
+  }
+  body.order = enumValue("order", rawOrder ?? DEFAULT_TELEMETRY_ORDER, ["asc", "desc"])
+  for (const field of ["from", "to"] as const) {
+    const value = body[field]
+    if (value === undefined) continue
+    if (typeof value !== "string") fail(`${field} must be an RFC 3339 timestamp.`)
+    body[field] = rfc3339Value(field, value)
+  }
+  requireOrderedRange("from", body.from as string | undefined, "to", body.to as string | undefined)
+  return body
+}

package/src/commands/workflows.ts

@@ -0,0 +1,34 @@
+import type { ApiClient } from "../api-client"
+import { isHelp, parseCommandArgs, requestsHelp } from "../arguments"
+import { fail, writeJson, writeText } from "../output"
+import { GROUP_HELP } from "./metadata"
+import { readJson } from "./shared"
+
+export async function workflows(api: ApiClient, args: readonly string[]): Promise<void> {
+  const [sub, ...rest] = args
+  if (!sub || isHelp(sub) || requestsHelp(rest)) return writeText(GROUP_HELP.workflows)
+  if (sub === "list") {
+    parseCommandArgs(rest, {}, "workflows list")
+    return writeJson(await api.get("/api/workflows"))
+  }
+  if (sub === "get") {
+    const {
+      positionals: [workflowId],
+    } = parseCommandArgs(rest, {}, "workflows get", 1)
+    return writeJson(await api.get(`/api/workflows/${encodeURIComponent(workflowId ?? "")}`))
+  }
+  if (sub === "start") {
+    const {
+      positionals: [workflowId],
+      options,
+    } = parseCommandArgs(rest, { "--file": "string" }, "workflows start", 1)
+    const input: unknown = options["--file"] ? await readJson(options["--file"]) : {}
+    if (Array.isArray(input) || typeof input !== "object" || input === null) {
+      fail("Workflow input must be a JSON object.")
+    }
+    return writeJson(
+      await api.post(`/api/workflows/${encodeURIComponent(workflowId ?? "")}/runs`, { input })
+    )
+  }
+  fail(`Unknown workflows command '${sub}'.`)
+}