@oneworks/cli 0.1.0-alpha.0

package/src/commands/agent/runtime-store-commands.ts

@@ -0,0 +1,56 @@
+import { existsSync } from 'node:fs'
+import process from 'node:process'
+
+import { buildCommand, getStore, trimRequired } from './runtime-store-shared'
+import type { AppendRuntimeCommandParams } from './runtime-store-shared'
+
+export const appendRuntimeCommand = async (params: AppendRuntimeCommandParams) => {
+  const sessionId = trimRequired(params.sessionId, 'session')
+  const store = await getStore(params.cwd, params.env)
+  const session = store.session(sessionId)
+  if (!existsSync(session.sessionPath)) throw new Error(`Runtime session "${sessionId}" not found.`)
+
+  const content = params.type === 'send_message' || params.type === 'resume'
+    ? trimRequired(params.message, 'message')
+    : params.message?.trim()
+  const requestId = params.type === 'submit_input'
+    ? trimRequired(params.requestId, 'request')
+    : params.requestId?.trim()
+  const submitValue = params.value ?? params.data
+  if (params.type === 'submit_input' && submitValue == null) {
+    throw new Error('value is required.')
+  }
+  const value = typeof params.value === 'string' ? params.value.trim() : params.value
+  const data = params.data
+  const command = await session.appendCommand(buildCommand({
+    sessionId,
+    type: params.type,
+    ts: (params.now ?? Date.now)(),
+    content,
+    commandId: params.commandId,
+    memberKey: params.memberKey,
+    priority: params.priority,
+    requestId,
+    roomId: params.roomId,
+    runId: params.runId,
+    source: params.source,
+    value,
+    data
+  }))
+
+  return {
+    ok: true,
+    commandId: command.commandId ?? command.id,
+    runtimeCommandId: command.id,
+    sessionId,
+    storePath: session.sessionPath,
+    type: command.type,
+    status: 'queued' as const
+  }
+}
+
+export const readRuntimeCommands = async (
+  cwd: string,
+  sessionId: string,
+  env: NodeJS.ProcessEnv = process.env
+) => (await getStore(cwd, env)).session(sessionId).readCommands()

package/src/commands/agent/runtime-store-events.ts

@@ -0,0 +1,23 @@
+import { existsSync } from 'node:fs'
+import process from 'node:process'
+
+import type { RuntimeEvent, RuntimeEventDraft } from '@oneworks/runtime-store'
+
+import { getStore } from './runtime-store-shared'
+
+export const readRuntimeEvents = async (
+  cwd: string,
+  sessionId: string,
+  env: NodeJS.ProcessEnv = process.env
+) => {
+  const session = (await getStore(cwd, env)).session(sessionId)
+  if (!existsSync(session.sessionPath)) throw new Error(`Runtime session "${sessionId}" not found.`)
+  return session.replayEvents()
+}
+
+export const appendRuntimeEventForTest = async (
+  cwd: string,
+  sessionId: string,
+  event: RuntimeEvent | RuntimeEventDraft,
+  env: NodeJS.ProcessEnv = process.env
+) => (await getStore(cwd, env)).session(sessionId).appendEvent(event)

package/src/commands/agent/runtime-store-session.ts

@@ -0,0 +1,170 @@
+import { existsSync } from 'node:fs'
+import path from 'node:path'
+import process from 'node:process'
+
+import { DEFAULT_SUPPORTED_PROTOCOL_RANGE, getCurrentProtocolVersion } from '@oneworks/runtime-protocol'
+import { getSessionStorePath, resolveRuntimeRoot } from '@oneworks/runtime-store'
+import type { RuntimeHeartbeat, RuntimeMeta, RuntimeState } from '@oneworks/runtime-store'
+
+import { buildCommand, createSessionId, getStore, trimRequired } from './runtime-store-shared'
+import type { CreateRuntimeSessionParams } from './runtime-store-shared'
+
+export const createRuntimeRoomIdForHostSession = (hostSessionId: string) => `room_${hostSessionId}`
+
+export const resolveRuntimeSessionStore = async (
+  cwd: string,
+  sessionId: string,
+  env: NodeJS.ProcessEnv = process.env
+) => {
+  const root = await resolveRuntimeRoot({ cwd, env })
+  const storePath = getSessionStorePath(root, trimRequired(sessionId, 'session'))
+  return {
+    root,
+    sessionId,
+    storePath,
+    metaPath: path.resolve(storePath, 'meta.json'),
+    eventsPath: path.resolve(storePath, 'events.jsonl'),
+    commandsPath: path.resolve(storePath, 'commands.jsonl'),
+    statePath: path.resolve(storePath, 'state.json'),
+    heartbeatPath: path.resolve(storePath, 'heartbeat.json'),
+    locksPath: path.resolve(storePath, 'locks')
+  }
+}
+
+export const createRuntimeSession = async (params: CreateRuntimeSessionParams) => {
+  const now = params.now ?? Date.now
+  const sessionId = params.sessionId ?? createSessionId()
+  const entity = trimRequired(params.entity, 'entity')
+  const content = trimRequired(params.message, 'message')
+  const title = params.title?.trim() || `${entity} session`
+  const adapter = params.adapter?.trim() || undefined
+  const effort = params.effort
+  const model = params.model?.trim() || undefined
+  const permissionMode = params.permissionMode
+  const parentSessionId = params.parentSessionId?.trim() || undefined
+  const hostSessionId = params.hostSessionId?.trim() || parentSessionId
+  const roomId = params.roomId?.trim() ||
+    (hostSessionId == null ? undefined : createRuntimeRoomIdForHostSession(hostSessionId))
+  const roomTitle = params.roomTitle?.trim() || undefined
+  const memberKey = params.memberKey?.trim() || entity
+  const memberAvatar = params.memberAvatar?.trim() || undefined
+  const memberLabel = params.memberLabel?.trim() || entity
+  const runId = params.runId?.trim() || sessionId
+  const runTitle = params.runTitle?.trim() || title
+  const ts = now()
+  const store = await getStore(params.cwd, params.env)
+  const session = await store.createSession(
+    {
+      protocolVersion: getCurrentProtocolVersion(),
+      supportedProtocolRange: DEFAULT_SUPPORTED_PROTOCOL_RANGE,
+      sessionId,
+      title,
+      entity,
+      ...(adapter != null ? { adapter } : {}),
+      ...(effort != null ? { effort } : {}),
+      ...(model != null ? { model } : {}),
+      ...(permissionMode != null ? { permissionMode } : {}),
+      cwd: params.cwd,
+      ...(parentSessionId != null ? { parentSessionId } : {}),
+      ...(roomId != null ? { roomId } : {}),
+      ...(roomTitle != null ? { roomTitle } : {}),
+      ...(hostSessionId != null ? { hostSessionId } : {}),
+      memberKey,
+      ...(memberAvatar != null ? { memberAvatar } : {}),
+      memberKind: 'entity',
+      memberLabel,
+      runId,
+      runTitle,
+      createdAt: ts,
+      needsEngineConsumer: true
+    } satisfies RuntimeMeta
+  )
+
+  await Promise.all([
+    session.writeState(buildInitialState({ sessionId, title, ts })),
+    session.writeHeartbeat(buildInitialHeartbeat({ sessionId, ts }))
+  ])
+  const startCommand = await session.appendCommand(buildCommand({
+    sessionId,
+    type: 'start',
+    ts,
+    content,
+    commandId: params.commandId,
+    entity,
+    adapter,
+    effort,
+    model,
+    memberKey,
+    permissionMode,
+    priority: params.priority,
+    ...(roomId != null ? { roomId } : {}),
+    runId,
+    source: params.source,
+    title
+  }))
+
+  return {
+    ...(params.commandId != null
+      ? {
+        commandId: startCommand.commandId,
+        runtimeCommandId: startCommand.id
+      }
+      : {}),
+    sessionId,
+    storePath: session.sessionPath,
+    status: 'starting',
+    title,
+    ...(hostSessionId != null ? { hostSessionId } : {}),
+    ...(roomId != null ? { roomId } : {})
+  }
+}
+
+const buildInitialState = (params: {
+  sessionId: string
+  title: string
+  ts: number
+}): RuntimeState => ({
+  protocolVersion: getCurrentProtocolVersion(),
+  supportedProtocolRange: DEFAULT_SUPPORTED_PROTOCOL_RANGE,
+  sessionId: params.sessionId,
+  status: 'starting',
+  title: params.title,
+  lastSeq: 0,
+  updatedAt: params.ts,
+  needsEngineConsumer: true
+})
+
+const buildInitialHeartbeat = (params: {
+  sessionId: string
+  ts: number
+}): RuntimeHeartbeat => ({
+  protocolVersion: getCurrentProtocolVersion(),
+  supportedProtocolRange: DEFAULT_SUPPORTED_PROTOCOL_RANGE,
+  sessionId: params.sessionId,
+  runtimeId: 'pending_engine_consumer',
+  status: 'starting',
+  updatedAt: params.ts
+})
+
+export const readRuntimeStatus = async (
+  cwd: string,
+  sessionId: string,
+  env: NodeJS.ProcessEnv = process.env
+) => {
+  const session = (await getStore(cwd, env)).session(sessionId)
+  if (!existsSync(session.sessionPath)) throw new Error(`Runtime session "${sessionId}" not found.`)
+  const [meta, state, heartbeat] = await Promise.all([
+    session.readMeta(),
+    session.readState(),
+    session.readHeartbeat()
+  ])
+  return {
+    sessionId,
+    storePath: session.sessionPath,
+    status: state?.status ?? heartbeat?.status ?? 'starting',
+    title: String(state?.title ?? meta?.title ?? ''),
+    meta,
+    state,
+    heartbeat
+  }
+}

package/src/commands/agent/runtime-store-shared.ts

@@ -0,0 +1,139 @@
+import { randomUUID } from 'node:crypto'
+import process from 'node:process'
+
+import { DEFAULT_SUPPORTED_PROTOCOL_RANGE, getCurrentProtocolVersion } from '@oneworks/runtime-protocol'
+import { FileRuntimeStore, resolveRuntimeRoot } from '@oneworks/runtime-store'
+import type { RuntimeCommand } from '@oneworks/runtime-store'
+
+export type RuntimeCommandType =
+  | 'start'
+  | 'send_message'
+  | 'stop'
+  | 'kill'
+  | 'submit_input'
+  | 'resume'
+
+export interface CreateRuntimeSessionParams {
+  cwd: string
+  entity: string
+  title?: string
+  message: string
+  adapter?: string
+  effort?: 'low' | 'medium' | 'high' | 'max'
+  model?: string
+  commandId?: string
+  env?: NodeJS.ProcessEnv
+  hostSessionId?: string
+  memberAvatar?: string
+  memberLabel?: string
+  memberKey?: string
+  now?: () => number
+  parentSessionId?: string
+  priority?: number
+  roomId?: string
+  roomTitle?: string
+  runId?: string
+  runTitle?: string
+  sessionId?: string
+  source?: string
+  permissionMode?: 'default' | 'acceptEdits' | 'plan' | 'dontAsk' | 'bypassPermissions'
+}
+
+export interface AppendRuntimeCommandParams {
+  cwd: string
+  sessionId: string
+  type: Exclude<RuntimeCommandType, 'start'>
+  commandId?: string
+  message?: string
+  memberKey?: string
+  priority?: number
+  requestId?: string
+  roomId?: string
+  runId?: string
+  source?: string
+  value?: unknown
+  data?: string | string[]
+  env?: NodeJS.ProcessEnv
+  now?: () => number
+}
+
+export const trimRequired = (value: string | undefined, name: string) => {
+  const normalized = value?.trim() ?? ''
+  if (normalized === '') throw new Error(`${name} is required.`)
+  return normalized
+}
+
+export const getStore = async (cwd: string, env: NodeJS.ProcessEnv = process.env) =>
+  new FileRuntimeStore(await resolveRuntimeRoot({ cwd, env }))
+
+const getCommandPriority = (type: RuntimeCommandType) => {
+  switch (type) {
+    case 'stop':
+    case 'kill':
+      return 0
+    case 'submit_input':
+      return 10
+    case 'start':
+    case 'send_message':
+    case 'resume':
+      return 20
+  }
+}
+
+const commandTypeToMode = (type: RuntimeCommandType) => {
+  if (type === 'stop') return 'graceful'
+  if (type === 'kill') return 'force'
+  return undefined
+}
+
+export const createSessionId = () => `sess_${randomUUID()}`
+
+export const buildCommand = (params: {
+  sessionId: string
+  type: RuntimeCommandType
+  ts: number
+  content?: string
+  commandId?: string
+  requestId?: string
+  value?: unknown
+  data?: string | string[]
+  entity?: string
+  adapter?: string
+  effort?: 'low' | 'medium' | 'high' | 'max'
+  model?: string
+  memberKey?: string
+  permissionMode?: 'default' | 'acceptEdits' | 'plan' | 'dontAsk' | 'bypassPermissions'
+  roomId?: string
+  runId?: string
+  priority?: number
+  source?: string
+  title?: string
+}): RuntimeCommand => {
+  const command: RuntimeCommand = {
+    protocolVersion: getCurrentProtocolVersion(),
+    supportedProtocolRange: DEFAULT_SUPPORTED_PROTOCOL_RANGE,
+    id: `cmd_${params.type}_${randomUUID()}`,
+    ts: params.ts,
+    sessionId: params.sessionId,
+    type: params.type,
+    priority: params.priority ?? getCommandPriority(params.type),
+    source: params.source ?? 'cli'
+  }
+  if (params.commandId != null) command.commandId = params.commandId
+  if (params.content != null) command.content = params.content
+  if (params.requestId != null) command.requestId = params.requestId
+  if (params.value != null) command.value = params.value
+  if (params.data != null) command.data = params.data
+  if (params.entity != null) command.entity = params.entity
+  if (params.adapter != null) command.adapter = params.adapter
+  if (params.effort != null) command.effort = params.effort
+  if (params.model != null) command.model = params.model
+  if (params.permissionMode != null) command.permissionMode = params.permissionMode
+  if (params.memberKey != null) command.memberKey = params.memberKey
+  if (params.roomId != null) command.roomId = params.roomId
+  if (params.runId != null) command.runId = params.runId
+  if (params.title != null) command.title = params.title
+  const mode = commandTypeToMode(params.type)
+  if (mode != null) command.mode = mode
+  return command
+}

package/src/commands/agent/runtime-store.ts

@@ -0,0 +1,4 @@
+export * from './runtime-store-commands'
+export * from './runtime-store-events'
+export * from './runtime-store-session'
+export type { RuntimeCommandType } from './runtime-store-shared'

package/src/commands/agent.ts

@@ -0,0 +1,81 @@
+import type { Command } from 'commander'
+
+import { runAgentAction, runAgentCommand, runAgentEvents, runAgentStart, runAgentStatus } from './agent/actions'
+import type { AgentEventsOptions, AgentSessionOptions, AgentStartOptions } from './agent/actions'
+
+export function registerAgentCommand(program: Command) {
+  const agentCommand = program
+    .command('agent')
+    .description('Operate agent runtime sessions through the runtime store protocol')
+
+  agentCommand
+    .command('start')
+    .description('Create a runtime session store and queue the initial start command')
+    .requiredOption('--entity <entity>', 'Entity key to start, for example dev or qa')
+    .requiredOption('--message <message>', 'Initial user message for the runtime session')
+    .option('--title <title>', 'Display title for the runtime session')
+    .option('--host-session <session>', 'Parent host session id for automatic room binding')
+    .option('--room <room>', 'Existing agent room id to attach to')
+    .option('--room-title <title>', 'Agent room title hint when a room is created')
+    .option('--avatar <avatar>', 'Avatar label shown for this room member')
+    .option('--json', 'Print JSON output', false)
+    .action((opts: AgentStartOptions) => runAgentAction(() => runAgentStart(opts)))
+
+  agentCommand
+    .command('send')
+    .description('Queue a message for an existing runtime session')
+    .requiredOption('--session <session>', 'Runtime session id')
+    .requiredOption('--message <message>', 'Message to send')
+    .option('--json', 'Print JSON output', false)
+    .action((opts: AgentSessionOptions & { session: string }) =>
+      runAgentAction(() => runAgentCommand(opts, 'send_message'))
+    )
+
+  agentCommand
+    .command('stop')
+    .description('Queue a graceful stop command for an existing runtime session')
+    .requiredOption('--session <session>', 'Runtime session id')
+    .option('--json', 'Print JSON output', false)
+    .action((opts: AgentSessionOptions & { session: string }) => runAgentAction(() => runAgentCommand(opts, 'stop')))
+
+  agentCommand
+    .command('kill')
+    .description('Queue a force-kill command for an existing runtime session')
+    .requiredOption('--session <session>', 'Runtime session id')
+    .option('--json', 'Print JSON output', false)
+    .action((opts: AgentSessionOptions & { session: string }) => runAgentAction(() => runAgentCommand(opts, 'kill')))
+
+  agentCommand
+    .command('submit')
+    .description('Queue a response to a pending runtime input request')
+    .requiredOption('--session <session>', 'Runtime session id')
+    .requiredOption('--request <request>', 'Pending input or approval request id')
+    .requiredOption('--value <value>', 'Submitted value')
+    .option('--json', 'Print JSON output', false)
+    .action((opts: AgentSessionOptions & { session: string }) =>
+      runAgentAction(() => runAgentCommand(opts, 'submit_input'))
+    )
+
+  agentCommand
+    .command('resume')
+    .description('Queue a resume command and optional follow-up message')
+    .requiredOption('--session <session>', 'Runtime session id')
+    .requiredOption('--message <message>', 'Resume message')
+    .option('--json', 'Print JSON output', false)
+    .action((opts: AgentSessionOptions & { session: string }) => runAgentAction(() => runAgentCommand(opts, 'resume')))
+
+  agentCommand
+    .command('status')
+    .description('Read runtime session status from state, heartbeat, and metadata files')
+    .requiredOption('--session <session>', 'Runtime session id')
+    .option('--json', 'Print JSON output', false)
+    .action((opts: AgentSessionOptions & { session: string }) => runAgentAction(() => runAgentStatus(opts)))
+
+  agentCommand
+    .command('events')
+    .description('Read or follow runtime session events')
+    .requiredOption('--session <session>', 'Runtime session id')
+    .option('--follow', 'Keep following the events.jsonl file', false)
+    .option('--jsonl', 'Print JSON Lines output', false)
+    .action((opts: AgentEventsOptions & { session: string }) => runAgentAction(() => runAgentEvents(opts)))
+}

package/src/commands/benchmark.ts

@@ -0,0 +1,198 @@
+import process from 'node:process'
+
+import {
+  getBenchmarkCase,
+  listBenchmarkCases,
+  listBenchmarkCategories,
+  readBenchmarkResult,
+  runBenchmarkCase,
+  runBenchmarkCategory
+} from '@oneworks/app-runtime'
+import type { BenchmarkCase, BenchmarkCategory, BenchmarkResult } from '@oneworks/types'
+import type { Command } from 'commander'
+
+import { createAdapterOption } from './@core/adapter-option'
+import { resolvePermissionModeOption } from './run/options'
+
+interface BenchmarkRunOptions {
+  category: string
+  title?: string
+  concurrency?: string
+  adapter?: string
+  model?: string
+  effort?: 'low' | 'medium' | 'high' | 'max'
+  systemPrompt?: string
+  permissionMode?: 'default' | 'acceptEdits' | 'plan' | 'dontAsk' | 'bypassPermissions'
+  yolo?: boolean
+}
+
+const printResult = (result: BenchmarkResult) => {
+  console.table([{
+    Category: result.category,
+    Title: result.title,
+    Status: result.status,
+    Score: result.finalScore,
+    Test: result.scores.testScore,
+    Goal: result.scores.goalScore,
+    Reference: result.scores.referenceScore,
+    DurationMs: result.durationMs,
+    Timestamp: result.timestamp
+  }])
+
+  if (result.issues.length > 0) {
+    console.log('\nIssues:')
+    for (const issue of result.issues) {
+      console.log(`- ${issue}`)
+    }
+  }
+}
+
+const createEventPrinter = () => {
+  return (event: {
+    category: string
+    title?: string
+    phase: string
+    message: string
+  }) => {
+    const target = event.title ? `${event.category}/${event.title}` : event.category
+    console.log(`[benchmark:${target}] [${event.phase}] ${event.message}`)
+  }
+}
+
+export function registerBenchmarkCommand(program: Command) {
+  const benchmark = program
+    .command('benchmark')
+    .description('List and run benchmark cases')
+
+  benchmark
+    .command('list')
+    .description('List benchmark categories and cases')
+    .option('--category <category>', 'Filter by category')
+    .action(async (opts: { category?: string }) => {
+      const categories = await listBenchmarkCategories()
+      const cases = await listBenchmarkCases({
+        category: opts.category
+      })
+
+      if (categories.length === 0) {
+        console.log('No benchmark cases found.')
+        return
+      }
+
+      console.log('Categories:')
+      console.table(categories.map((item: BenchmarkCategory) => ({
+        Category: item.category,
+        Cases: item.caseCount,
+        Pass: item.lastStatuses.pass,
+        Partial: item.lastStatuses.partial,
+        Fail: item.lastStatuses.fail
+      })))
+
+      if (cases.length === 0) {
+        console.log(`No cases found for category ${opts.category}.`)
+        return
+      }
+
+      console.log('\nCases:')
+      console.table(cases.map((item: BenchmarkCase) => ({
+        Category: item.category,
+        Title: item.title,
+        Summary: item.summary,
+        Status: item.latestResult?.status ?? '-',
+        Score: item.latestResult?.finalScore ?? '-'
+      })))
+    })
+
+  benchmark
+    .command('run')
+    .description('Run one benchmark case or an entire category')
+    .requiredOption('--category <category>', 'Benchmark category')
+    .option('--title <title>', 'Benchmark title')
+    .option('--concurrency <count>', 'Category concurrency', '2')
+    .addOption(createAdapterOption('Adapter to use'))
+    .option('--model <model>', 'Model to use')
+    .option('--effort <effort>', 'Effort to use (low, medium, high, max)')
+    .option('--system-prompt <prompt>', 'Additional system prompt')
+    .option('--permission-mode <mode>', 'Permission mode')
+    .option('--yolo', 'Shortcut for --permission-mode bypassPermissions', false)
+    .action(async (opts: BenchmarkRunOptions) => {
+      opts.permissionMode = resolvePermissionModeOption(opts.permissionMode, opts.yolo)
+      const onEvent = createEventPrinter()
+      if (opts.title != null && opts.title !== '') {
+        const output = await runBenchmarkCase({
+          category: opts.category,
+          title: opts.title,
+          adapter: opts.adapter,
+          model: opts.model,
+          effort: opts.effort,
+          systemPrompt: opts.systemPrompt,
+          permissionMode: opts.permissionMode,
+          runtime: 'cli',
+          onEvent
+        })
+        printResult(output.result)
+        process.exit(output.result.status === 'fail' ? 1 : 0)
+      }
+
+      const concurrency = Number.parseInt(opts.concurrency ?? '2', 10)
+      const output = await runBenchmarkCategory({
+        category: opts.category,
+        concurrency: Number.isNaN(concurrency) ? 2 : concurrency,
+        adapter: opts.adapter,
+        model: opts.model,
+        effort: opts.effort,
+        systemPrompt: opts.systemPrompt,
+        permissionMode: opts.permissionMode,
+        runtime: 'cli',
+        onEvent
+      })
+
+      console.table(output.results.map((result: BenchmarkResult) => ({
+        Title: result.title,
+        Status: result.status,
+        Score: result.finalScore,
+        Test: result.scores.testScore,
+        Goal: result.scores.goalScore,
+        Reference: result.scores.referenceScore
+      })))
+
+      const hasFailure = output.results.some((result: BenchmarkResult) => result.status === 'fail')
+      process.exit(hasFailure ? 1 : 0)
+    })
+
+  benchmark
+    .command('show')
+    .description('Show benchmark case metadata and latest result')
+    .requiredOption('--category <category>', 'Benchmark category')
+    .requiredOption('--title <title>', 'Benchmark title')
+    .action(async (opts: { category: string; title: string }) => {
+      const caseItem = await getBenchmarkCase(opts)
+      if (caseItem == null) {
+        console.error(`Benchmark case not found: ${opts.category}/${opts.title}`)
+        process.exit(1)
+      }
+
+      console.log('Case:')
+      console.table([{
+        Category: caseItem.category,
+        Title: caseItem.title,
+        Summary: caseItem.summary,
+        BaseCommit: caseItem.frontmatter.baseCommit,
+        Setup: caseItem.frontmatter.setupCommand,
+        Test: caseItem.frontmatter.testCommand,
+        TimeoutSec: caseItem.frontmatter.timeoutSec
+      }])
+
+      console.log('\nRFC:')
+      console.log(caseItem.rfcBody)
+
+      const result = await readBenchmarkResult(process.cwd(), opts.category, opts.title)
+      if (result == null) {
+        console.log('\nNo result.json found.')
+        return
+      }
+
+      console.log('\nLatest Result:')
+      printResult(result)
+    })
+}