boxdown 1.0.0

package/src/config.ts

@@ -0,0 +1,81 @@
+import { mkdirSync, readFileSync, statSync, writeFileSync } from 'node:fs'
+import { join } from 'node:path'
+
+import {
+  BOXDOWN_CONTAINER_AGENTS_DIR,
+  BOXDOWN_CONTAINER_DEVCONTAINER_DIR,
+  BOXDOWN_CONTAINER_SSH_DIR,
+  BOXDOWN_CONTAINER_SSH_PUBLIC_KEY_PATH
+} from './constants.ts'
+import { parseJsonc } from './jsonc.ts'
+import type { WorkspaceContext } from './paths.ts'
+import { shellQuote } from './shell.ts'
+
+export interface DevcontainerConfig {
+  name?: string
+  mounts?: string[]
+  containerEnv?: Record<string, string>
+  runArgs?: string[]
+  initializeCommand?: string
+  postCreateCommand?: string
+  postStartCommand?: string
+  [key: string]: unknown
+}
+
+export function readBaseDevcontainerConfig (assetsDevcontainerDir: string): DevcontainerConfig {
+  const configPath = join(assetsDevcontainerDir, 'devcontainer.json')
+  return parseJsonc<DevcontainerConfig>(readFileSync(configPath, 'utf8'))
+}
+
+function directoryExists (path: string): boolean {
+  try {
+    return statSync(path).isDirectory()
+  } catch {
+    return false
+  }
+}
+
+export function buildGeneratedDevcontainerConfig (context: WorkspaceContext): DevcontainerConfig {
+  const baseConfig = readBaseDevcontainerConfig(context.assetsDevcontainerDir)
+  const mounts = Array.isArray(baseConfig.mounts)
+    ? baseConfig.mounts.filter((mount): mount is string => typeof mount === 'string')
+    : []
+
+  const boxdownMounts = [
+    `type=bind,source=${context.assetsDevcontainerDir},target=${BOXDOWN_CONTAINER_DEVCONTAINER_DIR},readonly`,
+    `type=bind,source=${context.sshPublicKeyRuntimeDir},target=${BOXDOWN_CONTAINER_SSH_DIR},readonly`
+  ]
+
+  if (
+    directoryExists(context.hostAgentsDir) &&
+    !mounts.some((mount) => mount.includes(`target=${BOXDOWN_CONTAINER_AGENTS_DIR}`))
+  ) {
+    boxdownMounts.push(`type=bind,source=${context.hostAgentsDir},target=${BOXDOWN_CONTAINER_AGENTS_DIR},readonly`)
+  }
+
+  return {
+    ...baseConfig,
+    name: `Boxdown: ${context.workspaceBasename}`,
+    mounts: [...mounts, ...boxdownMounts],
+    initializeCommand: `BOXDOWN_WORKSPACE_FOLDER=${shellQuote(context.workspaceFolder)} bash ${shellQuote(join(context.assetsDevcontainerDir, 'hooks', 'initialize.sh'))}`,
+    postCreateCommand: `bash ${shellQuote(`${BOXDOWN_CONTAINER_DEVCONTAINER_DIR}/hooks/post-create.sh`)}`,
+    postStartCommand: `bash ${shellQuote(`${BOXDOWN_CONTAINER_DEVCONTAINER_DIR}/hooks/post-start.sh`)}`,
+    containerEnv: {
+      ...(baseConfig.containerEnv ?? {}),
+      BOXDOWN_CONTAINER_WORKSPACE_FOLDER: '/workspaces/${localWorkspaceFolderBasename}',
+      BOXDOWN_WORKSPACE_BASENAME: '${localWorkspaceFolderBasename}',
+      DEVCONTAINER_SSH_PUBLIC_KEY_FILE: BOXDOWN_CONTAINER_SSH_PUBLIC_KEY_PATH
+    }
+  }
+}
+
+export function writeGeneratedDevcontainerConfig (context: WorkspaceContext): DevcontainerConfig {
+  const config = buildGeneratedDevcontainerConfig(context)
+  mkdirSync(context.workspaceCacheDir, { recursive: true })
+  writeFileSync(context.generatedConfigPath, `${JSON.stringify(config, null, 2)}\n`)
+  return config
+}
+
+export function publishContainerPortFromConfig (config: DevcontainerConfig): string | undefined {
+  return config.runArgs?.find((arg) => /^[0-9.]+::[0-9]+$/.test(arg))?.split('::')[1]
+}

package/src/constants.ts

@@ -0,0 +1,9 @@
+export const DEVCONTAINER_CLI_VERSION = '0.84.1'
+
+export const BOXDOWN_CONTAINER_DEVCONTAINER_DIR = '/opt/boxdown/devcontainer'
+export const BOXDOWN_CONTAINER_STATE_DIR = '/opt/boxdown/state'
+export const BOXDOWN_CONTAINER_SSH_DIR = `${BOXDOWN_CONTAINER_STATE_DIR}/ssh`
+export const BOXDOWN_CONTAINER_SSH_PUBLIC_KEY_PATH = `${BOXDOWN_CONTAINER_SSH_DIR}/id_ed25519.pub`
+export const BOXDOWN_CONTAINER_AGENTS_DIR = '/home/node/.agents'
+
+export const PACKAGE_NAME = 'boxdown'

package/src/devcontainer-cli.ts

@@ -0,0 +1,57 @@
+import { existsSync, readFileSync } from 'node:fs'
+import { createRequire } from 'node:module'
+import { dirname, join, resolve } from 'node:path'
+
+import { DEVCONTAINER_CLI_VERSION } from './constants.ts'
+import type { WorkspaceContext } from './paths.ts'
+
+export interface DevcontainerCliCommand {
+  command: string
+  argsPrefix: string[]
+  path: string
+  version: string
+}
+
+interface PackageJson {
+  bin?: string | Record<string, string>
+  version?: string
+}
+
+function devcontainerBinFromPackageJson (packageJson: PackageJson): string | undefined {
+  return typeof packageJson.bin === 'string' ? packageJson.bin : packageJson.bin?.devcontainer
+}
+
+export function resolveDevcontainerCli (context: WorkspaceContext): DevcontainerCliCommand {
+  const requireFromBoxdown = createRequire(join(context.packageRoot, 'package.json'))
+  let packageJsonPath: string
+
+  try {
+    packageJsonPath = requireFromBoxdown.resolve('@devcontainers/cli/package.json')
+  } catch (error) {
+    throw new Error(`Boxdown's packaged @devcontainers/cli dependency is missing. Reinstall boxdown so @devcontainers/cli@${DEVCONTAINER_CLI_VERSION} is available.`, { cause: error })
+  }
+
+  const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf8')) as PackageJson
+  const bin = devcontainerBinFromPackageJson(packageJson)
+
+  if (packageJson.version !== DEVCONTAINER_CLI_VERSION) {
+    throw new Error(`Boxdown expected @devcontainers/cli@${DEVCONTAINER_CLI_VERSION} but resolved ${packageJson.version ?? 'an unknown version'}.`)
+  }
+
+  if (bin === undefined) {
+    throw new Error('Boxdown resolved @devcontainers/cli, but the package does not expose a devcontainer binary.')
+  }
+
+  const cliPath = resolve(dirname(packageJsonPath), bin)
+
+  if (!existsSync(cliPath)) {
+    throw new Error(`Boxdown resolved @devcontainers/cli, but its devcontainer binary is missing: ${cliPath}`)
+  }
+
+  return {
+    command: process.execPath,
+    argsPrefix: [cliPath],
+    path: cliPath,
+    version: packageJson.version
+  }
+}

package/src/devcontainer.ts

@@ -0,0 +1,394 @@
+import {
+  BOXDOWN_CONTAINER_DEVCONTAINER_DIR
+} from './constants.ts'
+import { buildGeneratedDevcontainerConfig, publishContainerPortFromConfig, writeGeneratedDevcontainerConfig } from './config.ts'
+import { codingAgentBinary, type CodingAgentCli } from './coding-agents.ts'
+import { resolveDevcontainerCli } from './devcontainer-cli.ts'
+import { configureWorkspaceGithubGitAuth } from './github-git-auth.ts'
+import type { WorkspaceContext } from './paths.ts'
+import { runBuffered, runInteractive } from './process.ts'
+import { interactiveCommandScript, interactiveShellEnvArgs, interactiveShellScript } from './shell.ts'
+import { ensureHostSshKey } from './ssh-key.ts'
+import { type ContainerSummary, parseDockerPsJsonLines } from './status.ts'
+
+export interface StartOptions {
+  recreate?: boolean
+  proxyMode?: boolean
+  reuseRunning?: boolean
+}
+
+function devcontainerWorkspaceArgs (context: WorkspaceContext): string[] {
+  return [
+    '--workspace-folder',
+    context.workspaceFolder,
+    '--override-config',
+    context.generatedConfigPath
+  ]
+}
+
+function log (message: string, proxyMode = false): void {
+  if (proxyMode) {
+    process.stderr.write(`${message}\n`)
+  } else {
+    process.stdout.write(`${message}\n`)
+  }
+}
+
+export function parseContainerIdFromUpOutput (output: string): string | undefined {
+  return /"containerId"\s*:\s*"([^"]+)"/.exec(output)?.[1]
+}
+
+export async function findWorkspaceContainer (context: WorkspaceContext): Promise<ContainerSummary | undefined> {
+  const result = await runBuffered('docker', [
+    'ps',
+    '-a',
+    '--filter',
+    `label=devcontainer.local_folder=${context.workspaceFolder}`,
+    '--format',
+    '{{json .}}'
+  ], {
+    mirrorStdout: false,
+    mirrorStderr: false
+  })
+
+  if (result.code !== 0) {
+    throw new Error(`Could not inspect devcontainer for ${context.workspaceFolder}`)
+  }
+
+  return parseDockerPsJsonLines(result.stdout)[0]
+}
+
+export async function listWorkspaceContainers (): Promise<ContainerSummary[] | undefined> {
+  const result = await runBuffered('docker', [
+    'ps',
+    '-a',
+    '--filter',
+    'label=devcontainer.local_folder',
+    '--format',
+    '{{json .}}'
+  ], {
+    mirrorStdout: false,
+    mirrorStderr: false
+  })
+
+  if (result.code !== 0) {
+    return undefined
+  }
+
+  return parseDockerPsJsonLines(result.stdout)
+}
+
+export async function findRunningContainerId (context: WorkspaceContext): Promise<string | undefined> {
+  const result = await runBuffered('docker', [
+    'ps',
+    '--filter',
+    `label=devcontainer.local_folder=${context.workspaceFolder}`,
+    '--format',
+    '{{.ID}}'
+  ], {
+    mirrorStdout: false,
+    mirrorStderr: false
+  })
+
+  if (result.code !== 0) {
+    return undefined
+  }
+
+  return result.stdout.split(/\r?\n/).find((line) => line.length > 0)
+}
+
+export async function stopWorkspaceContainer (context: WorkspaceContext): Promise<void> {
+  const container = await findWorkspaceContainer(context)
+
+  if (container === undefined) {
+    process.stdout.write(`No devcontainer found for: ${context.workspaceFolder}\n`)
+    return
+  }
+
+  if (container.state?.toLowerCase() !== 'running') {
+    process.stdout.write(`Devcontainer is not running for: ${context.workspaceFolder}\n`)
+    return
+  }
+
+  const result = await runBuffered('docker', ['stop', container.id], {
+    mirrorStdout: false,
+    mirrorStderr: false
+  })
+
+  if (result.code !== 0) {
+    throw new Error(`Could not stop devcontainer ${container.id}`)
+  }
+
+  process.stdout.write(`Stopped devcontainer: ${container.id}\n`)
+}
+
+export async function removeWorkspaceContainer (context: WorkspaceContext): Promise<void> {
+  const container = await findWorkspaceContainer(context)
+
+  if (container === undefined) {
+    process.stdout.write(`No devcontainer found for: ${context.workspaceFolder}\n`)
+    return
+  }
+
+  const result = await runBuffered('docker', ['rm', '-f', container.id], {
+    mirrorStdout: false,
+    mirrorStderr: false
+  })
+
+  if (result.code !== 0) {
+    throw new Error(`Could not remove devcontainer ${container.id}`)
+  }
+
+  process.stdout.write(`Removed devcontainer: ${container.id}\n`)
+}
+
+export async function startDevcontainer (context: WorkspaceContext, options: StartOptions = {}): Promise<string> {
+  await ensureHostSshKey(context, options.proxyMode ?? false)
+  writeGeneratedDevcontainerConfig(context)
+
+  if (options.reuseRunning === true && options.recreate !== true) {
+    const runningContainerId = await findRunningContainerId(context)
+
+    if (runningContainerId !== undefined) {
+      log(`Using running devcontainer for: ${context.workspaceFolder}`, options.proxyMode)
+      return runningContainerId
+    }
+  }
+
+  const cli = resolveDevcontainerCli(context)
+  log(`Starting devcontainer for: ${context.workspaceFolder}`, options.proxyMode)
+
+  const args = [
+    'up',
+    ...devcontainerWorkspaceArgs(context)
+  ]
+
+  if (options.recreate === true) {
+    args.push('--remove-existing-container')
+    log('Removing existing dev container so create-time settings apply.', options.proxyMode)
+  }
+
+  const result = await runBuffered(cli.command, [...cli.argsPrefix, ...args], {
+    mirrorStdout: options.proxyMode === true ? 'stderr' : 'stdout',
+    mirrorStderr: 'stderr'
+  })
+
+  if (result.code !== 0) {
+    throw new Error(`devcontainer up failed for ${context.workspaceFolder}`)
+  }
+
+  const containerId = parseContainerIdFromUpOutput(`${result.stdout}\n${result.stderr}`) ?? await findRunningContainerId(context)
+
+  if (containerId === undefined) {
+    throw new Error(`Could not resolve devcontainer ID for ${context.workspaceFolder}`)
+  }
+
+  return containerId
+}
+
+export async function printPortHint (context: WorkspaceContext, containerId: string): Promise<void> {
+  const config = buildGeneratedDevcontainerConfig(context)
+  const containerPort = publishContainerPortFromConfig(config)
+
+  if (containerPort === undefined) {
+    process.stderr.write('Warning: could not find a runArgs publish port.\n')
+    return
+  }
+
+  const result = await runBuffered('docker', ['port', containerId, `${containerPort}/tcp`], {
+    mirrorStdout: false,
+    mirrorStderr: false
+  })
+
+  const hostBinding = result.stdout.split(/\r?\n/).find((line) => line.length > 0)
+
+  if (result.code === 0 && hostBinding !== undefined) {
+    process.stdout.write(`\nDev server available at: http://${hostBinding}\n\n`)
+  } else {
+    process.stderr.write(`Warning: container is running but port ${containerPort}/tcp is not mapped.\n`)
+  }
+}
+
+export async function openShell (context: WorkspaceContext): Promise<number> {
+  const cli = resolveDevcontainerCli(context)
+  process.stdout.write('Dropping into container shell...\n')
+
+  return runInteractive(cli.command, [
+    ...cli.argsPrefix,
+    'exec',
+    ...devcontainerWorkspaceArgs(context),
+    '--',
+    'env',
+    ...interactiveShellEnvArgs(),
+    'bash',
+    '-c',
+    interactiveShellScript()
+  ])
+}
+
+export function codingAgentDevcontainerExecArgs (context: WorkspaceContext, agent: CodingAgentCli, agentArgs: string[] = []): string[] {
+  return [
+    'exec',
+    ...devcontainerWorkspaceArgs(context),
+    '--',
+    'env',
+    ...interactiveShellEnvArgs(),
+    'bash',
+    '-c',
+    interactiveCommandScript(),
+    'boxdown-agent',
+    codingAgentBinary(agent),
+    ...agentArgs
+  ]
+}
+
+export async function openCodingAgentCli (context: WorkspaceContext, agent: CodingAgentCli, agentArgs: string[] = []): Promise<number> {
+  const cli = resolveDevcontainerCli(context)
+  process.stdout.write(`Dropping into ${codingAgentBinary(agent)} inside the devcontainer...\n`)
+
+  return runInteractive(cli.command, [
+    ...cli.argsPrefix,
+    ...codingAgentDevcontainerExecArgs(context, agent, agentArgs)
+  ])
+}
+
+export async function ensureContainerSshRuntime (context: WorkspaceContext): Promise<void> {
+  const cli = resolveDevcontainerCli(context)
+  const result = await runBuffered(cli.command, [
+    ...cli.argsPrefix,
+    'exec',
+    ...devcontainerWorkspaceArgs(context),
+    '--',
+    'bash',
+    `${BOXDOWN_CONTAINER_DEVCONTAINER_DIR}/utils/ssh-bootstrap.sh`,
+    'runtime'
+  ], {
+    mirrorStdout: 'stderr',
+    mirrorStderr: 'stderr'
+  })
+
+  if (result.code !== 0) {
+    throw new Error('Failed to prepare devcontainer SSH runtime')
+  }
+}
+
+export async function refreshContainerCodingAgentClis (context: WorkspaceContext, proxyMode = false, agents: CodingAgentCli[] = []): Promise<void> {
+  const cli = resolveDevcontainerCli(context)
+  const result = await runBuffered(cli.command, [
+    ...cli.argsPrefix,
+    'exec',
+    ...devcontainerWorkspaceArgs(context),
+    '--',
+    'bash',
+    `${BOXDOWN_CONTAINER_DEVCONTAINER_DIR}/utils/coding-agent-cli-update.sh`,
+    'maybe-update',
+    ...agents
+  ], {
+    mirrorStdout: proxyMode ? 'stderr' : 'stdout',
+    mirrorStderr: 'stderr'
+  })
+
+  if (result.code !== 0) {
+    process.stderr.write('Warning: could not refresh one or more coding-agent CLIs inside the devcontainer.\n')
+  }
+}
+
+export async function runSshdProxy (containerId: string): Promise<number> {
+  return runInteractive('docker', [
+    'exec',
+    '-i',
+    containerId,
+    '/usr/sbin/sshd',
+    '-i',
+    '-o',
+    'LogLevel=QUIET',
+    '-o',
+    'PubkeyAuthentication=yes',
+    '-o',
+    'PasswordAuthentication=no',
+    '-o',
+    'KbdInteractiveAuthentication=no',
+    '-o',
+    'AllowTcpForwarding=yes',
+    '-o',
+    'AllowStreamLocalForwarding=yes',
+    '-o',
+    'PermitTTY=yes'
+  ])
+}
+
+async function hostGhTokenOrEmpty (): Promise<string> {
+  const result = await runBuffered('gh', ['auth', 'token'], {
+    mirrorStdout: false,
+    mirrorStderr: false
+  })
+
+  if (result.code !== 0) {
+    return ''
+  }
+
+  return result.stdout.trim()
+}
+
+export async function refreshContainerGhAuth (context: WorkspaceContext): Promise<void> {
+  await ensureHostSshKey(context, true)
+  writeGeneratedDevcontainerConfig(context)
+
+  const token = await hostGhTokenOrEmpty()
+
+  if (token.length === 0) {
+    return
+  }
+
+  const cli = resolveDevcontainerCli(context)
+  const login = await runBuffered(cli.command, [
+    ...cli.argsPrefix,
+    'exec',
+    ...devcontainerWorkspaceArgs(context),
+    '--',
+    'gh',
+    'auth',
+    'login',
+    '--hostname',
+    'github.com',
+    '--git-protocol',
+    'https',
+    '--with-token',
+    '--insecure-storage'
+  ], {
+    input: `${token}\n`,
+    mirrorStdout: false,
+    mirrorStderr: false
+  })
+
+  if (login.code !== 0) {
+    process.stderr.write('Warning: could not refresh GitHub CLI auth inside the devcontainer.\n')
+    return
+  }
+
+  const gitAuthConfigured = await configureWorkspaceGithubGitAuth(context.workspaceFolder)
+  if (!gitAuthConfigured) {
+    process.stderr.write('Warning: GitHub CLI auth refreshed, but GitHub Git auth was not configured for this workspace.\n')
+  }
+
+  const verify = await runBuffered(cli.command, [
+    ...cli.argsPrefix,
+    'exec',
+    ...devcontainerWorkspaceArgs(context),
+    '--',
+    'gh',
+    'auth',
+    'status',
+    '--hostname',
+    'github.com'
+  ], {
+    mirrorStdout: false,
+    mirrorStderr: false
+  })
+
+  if (verify.code === 0) {
+    process.stdout.write('GitHub CLI auth refreshed inside the devcontainer.\n')
+  } else {
+    process.stderr.write('Warning: GitHub CLI auth refresh completed, but verification failed.\n')
+  }
+}

package/src/doctor.ts

@@ -0,0 +1,139 @@
+import { existsSync } from 'node:fs'
+
+import { resolveDevcontainerCli } from './devcontainer-cli.ts'
+import type { WorkspaceContext } from './paths.ts'
+import { runBuffered } from './process.ts'
+
+export type DoctorLevel = 'ok' | 'fail' | 'warn'
+
+export interface DoctorCheck {
+  name: string
+  level: DoctorLevel
+  message: string
+}
+
+function nodeVersionPasses (version: string): boolean {
+  const major = Number.parseInt(version.split('.')[0] ?? '', 10)
+  return Number.isInteger(major) && major >= 24
+}
+
+function check (name: string, pass: boolean, okMessage: string, failMessage: string): DoctorCheck {
+  return {
+    name,
+    level: pass ? 'ok' : 'fail',
+    message: pass ? okMessage : failMessage
+  }
+}
+
+async function commandWorks (command: string, args: string[]): Promise<boolean> {
+  const result = await runBuffered(command, args, {
+    mirrorStdout: false,
+    mirrorStderr: false
+  })
+
+  return result.code === 0
+}
+
+async function commandExists (command: string, args: string[]): Promise<boolean> {
+  const result = await runBuffered(command, args, {
+    mirrorStdout: false,
+    mirrorStderr: false
+  })
+
+  return result.code !== 127
+}
+
+export async function runDoctorChecks (context: WorkspaceContext): Promise<DoctorCheck[]> {
+  const checks: DoctorCheck[] = []
+  const nodeVersion = process.versions.node
+
+  checks.push(check(
+    'node',
+    nodeVersionPasses(nodeVersion),
+    `Node ${nodeVersion}`,
+    `Node ${nodeVersion}; expected >=24.0.0`
+  ))
+
+  checks.push(check(
+    'devcontainers-cli',
+    await packagedDevcontainerCliWorks(context),
+    'Packaged @devcontainers/cli is available',
+    'Packaged @devcontainers/cli is required but was not available'
+  ))
+
+  checks.push(check(
+    'docker-cli',
+    await commandWorks('docker', ['--version']),
+    'Docker CLI is available',
+    'Docker CLI is required but was not available'
+  ))
+
+  checks.push(check(
+    'docker-daemon',
+    await commandWorks('docker', ['info']),
+    'Docker daemon is reachable',
+    'Docker daemon is required but was not reachable'
+  ))
+
+  checks.push(check(
+    'ssh',
+    await commandExists('ssh', ['-V']),
+    'ssh is available',
+    'ssh is required but was not available'
+  ))
+
+  checks.push(check(
+    'ssh-keygen',
+    await commandExists('ssh-keygen', ['-?']),
+    'ssh-keygen is available',
+    'ssh-keygen is required but was not available'
+  ))
+
+  checks.push(check(
+    'assets',
+    existsSync(context.assetsDevcontainerDir),
+    `Devcontainer assets found at ${context.assetsDevcontainerDir}`,
+    `Missing Boxdown devcontainer assets: ${context.assetsDevcontainerDir}`
+  ))
+
+  if (await commandWorks('gh', ['--version'])) {
+    const ghAuth = await commandWorks('gh', ['auth', 'status', '--hostname', 'github.com'])
+    checks.push({
+      name: 'gh-auth',
+      level: ghAuth ? 'ok' : 'warn',
+      message: ghAuth ? 'GitHub CLI auth is available' : 'GitHub CLI is available but not authenticated'
+    })
+  } else {
+    checks.push({
+      name: 'gh',
+      level: 'warn',
+      message: 'GitHub CLI is optional and was not available'
+    })
+  }
+
+  return checks
+}
+
+async function packagedDevcontainerCliWorks (context: WorkspaceContext): Promise<boolean> {
+  try {
+    const cli = resolveDevcontainerCli(context)
+    return await commandWorks(cli.command, [...cli.argsPrefix, '--version'])
+  } catch {
+    return false
+  }
+}
+
+export function doctorHasFailures (checks: DoctorCheck[]): boolean {
+  return checks.some((item) => item.level === 'fail')
+}
+
+export function formatDoctorText (checks: DoctorCheck[]): string {
+  const lines = ['Boxdown doctor', '']
+
+  for (const item of checks) {
+    lines.push(`[${item.level}] ${item.name}: ${item.message}`)
+  }
+
+  lines.push('', doctorHasFailures(checks) ? 'Result: failed' : 'Result: ok')
+  return `${lines.join('\n')}\n`
+}