@gamecrate/cli 0.1.0 → 1.0.0

package/src/cli/help.ts

@@ -1,193 +0,0 @@
-import type { GameConfig, RootConfig } from '../types'
-import { GamecrateError, Exit, own } from '../types'
-import type { Option } from 'commander'
-import { FLAG_ENV, GLOBAL_FLAGS, SUBCOMMANDS, buildProgram, suggest } from './args'
-import type { SubcommandSpec } from './args'
-
-const NAME = 'gamecrate'
-
-/** Help and completion describe whatever the parser accepts, never a second list. */
-function flags(): readonly Option[] {
-  return buildProgram().options
-}
-
-/**
- * Three levels: no topic gives the top level, a subcommand name gives its usage,
- * a game name gives that game's profiles and modes.
- */
-export function renderHelp(topic?: string, config?: RootConfig): string {
-  if (!topic) return topLevel(config)
-
-  const sub = SUBCOMMANDS.find((s) => s.name === topic)
-  if (sub) return subcommandHelp(sub)
-
-  const game = own(config?.games, topic)
-  if (game) return gameHelp(topic, game)
-
-  const candidates = [...SUBCOMMANDS.map((s) => s.name), ...Object.keys(config?.games ?? {})]
-  const hint = suggest(topic, candidates)
-  throw new GamecrateError(
-    `no help topic ${topic}`,
-    Exit.Usage,
-    hint ? `did you mean ${hint}?` : `topics: ${candidates.join(', ')}`,
-  )
-}
-
-function topLevel(config?: RootConfig): string {
-  const lines = [
-    `${NAME} — run modded games in containers`,
-    '',
-    'usage:',
-    `  ${NAME} <game> [profile] [flags] [-- game args]`,
-    `  ${NAME} <subcommand> [args] [flags]`,
-    '',
-    'subcommands:',
-  ]
-
-  const verbs = SUBCOMMANDS.map((s) => [`${s.name} ${s.usage}`.trim(), s.summary] as const)
-  lines.push(...columns(verbs, 2))
-  lines.push('', 'flags:')
-  lines.push(...columns(flags().map(flagRow), 2))
-
-  const games = Object.entries(config?.games ?? {})
-  if (games.length > 0) {
-    lines.push('', 'games:')
-    lines.push(...columns(games.map(([name, game]) => [name, gameSummary(game)] as const), 2))
-    lines.push('', `${NAME} help <game> lists that game's profiles.`)
-  }
-
-  lines.push('', 'Game args go after a bare --. Env vars are GAMECRATE_ prefixed fallbacks only.')
-  return lines.join('\n') + '\n'
-}
-
-function subcommandHelp(sub: SubcommandSpec): string {
-  const lines = [`usage: ${NAME} ${sub.name} ${sub.usage}`.trimEnd() + ' [flags]', '', `  ${sub.summary}`]
-
-  const names = [...sub.flags, ...GLOBAL_FLAGS]
-  const all = flags()
-  const specs = names
-    .map((name) => all.find((f) => f.long === name))
-    .filter((f): f is Option => f !== undefined)
-  if (specs.length > 0) {
-    lines.push('', 'flags:')
-    lines.push(...columns(specs.map(flagRow), 2))
-  }
-  if (sub.name === 'run') {
-    lines.push('', `  The subcommand slot defaults to run, so \`${NAME} <game> <profile>\` works.`)
-  }
-  return lines.join('\n') + '\n'
-}
-
-function gameHelp(name: string, game: GameConfig): string {
-  const lines = [`usage: ${NAME} ${name} [profile] [flags] [-- game args]`, '', 'profiles:']
-
-  const rows: (readonly [string, string])[] = []
-  for (const [profile, config] of Object.entries(game.profiles)) {
-    const notes: string[] = []
-    if (config.alias) notes.push(`alias for ${config.alias}`)
-    if (config.extends) notes.push(`extends ${config.extends}`)
-    if (config.autoDependencies) notes.push('auto dependencies')
-    const count = config.mods?.length ?? 0
-    if (!config.alias) notes.push(count === 1 ? '1 entry' : `${count} entries`)
-  if (config.aliases?.length) notes.push(`aka ${config.aliases.join(', ')}`)
-    rows.push([profile, notes.join(', ')])
-  }
-  if (rows.length === 0) rows.push(['(none declared)', ''])
-  lines.push(...columns(rows, 2))
-
-  if (game.aliases && Object.keys(game.aliases).length > 0) {
-    lines.push('', 'mod name aliases:')
-    lines.push(...columns(Object.entries(game.aliases).map(([k, v]) => [k, v] as const), 2))
-  }
-
-  lines.push('', `modes: ${game.modes.join(', ')}`)
-  lines.push(`core: ${game.core}`)
-  if (game.dlc.length > 0) lines.push(`dlc: ${game.dlc.join(', ')}`)
-  lines.push(`game files: ${game.gameFiles.source === 'mount' ? game.gameFiles.host ?? '(unset)' : game.image.ref}`)
-  return lines.join('\n') + '\n'
-}
-
-function gameSummary(game: GameConfig): string {
-  const count = Object.keys(game.profiles).length
-  return `${count === 1 ? '1 profile' : `${count} profiles`}; modes ${game.modes.join(', ')}`
-}
-
-function flagRow(spec: Option): readonly [string, string] {
-  const notes: string[] = []
-  if (Array.isArray(spec.defaultValue)) notes.push('repeatable')
-  const env = FLAG_ENV[spec.long ?? '']
-  if (env) notes.push(`$${env}`)
-  const summary = spec.description
-  return [spec.flags, notes.length > 0 ? `${summary} (${notes.join(', ')})` : summary]
-}
-
-/** The `<id>` part of a flag string, for the shell completions. */
-function placeholder(spec: Option): string {
-  return spec.flags.split(/[ ,]+/).find((token) => token.startsWith('<')) ?? ''
-}
-
-function columns(rows: readonly (readonly [string, string])[], indent: number): string[] {
-  const width = Math.max(0, ...rows.map((r) => r[0].length))
-  const pad = ' '.repeat(indent)
-  return rows.map(([left, right]) => (right ? `${pad}${left.padEnd(width)}  ${right}` : `${pad}${left}`))
-}
-
-export function renderCompletion(shell: 'bash' | 'zsh'): string {
-  const verbs = SUBCOMMANDS.map((s) => s.name).join(' ')
-  const options = flags()
-  const names = options.flatMap((f) => (f.short ? [f.long!, f.short] : [f.long!])).join(' ')
-  const valueFlags = options.filter((f) => f.required).map((f) => f.long!)
-  const fn = `_${NAME.replace(/-/g, '_')}`
-
-  if (shell === 'bash') {
-    const cases = options
-      .filter((f) => f.argChoices)
-      .map((f) => `    ${f.long}) COMPREPLY=($(compgen -W "${f.argChoices!.join(' ')}" -- "$cur")); return ;;`)
-      .join('\n')
-    return `${fn}() {
-  local cur prev
-  cur="\${COMP_WORDS[COMP_CWORD]}"
-  prev="\${COMP_WORDS[COMP_CWORD-1]}"
-  case "$prev" in
-${cases}
-    ${valueFlags.join('|')}) return ;;
-  esac
-  if [[ "$cur" == -* ]]; then
-    COMPREPLY=($(compgen -W "${names}" -- "$cur"))
-    return
-  fi
-  if [[ $COMP_CWORD -eq 1 ]]; then
-    local games
-    games=$(${NAME} list --json 2>/dev/null | grep -oE '"[A-Za-z0-9._-]+"' | tr -d '"')
-    COMPREPLY=($(compgen -W "${verbs} $games" -- "$cur"))
-  fi
-}
-complete -F ${fn} ${NAME}
-`
-  }
-
-  const zshVerbs = SUBCOMMANDS.map((s) => `    '${s.name}:${s.summary.replace(/'/g, "'\\''")}'`).join('\n')
-  const zshFlags = options.map((f) => {
-    const desc = f.description.replace(/'/g, "'\\''").replace(/[[\]:]/g, '')
-    const arg = placeholder(f)
-    const value = arg ? `:${arg.replace(/[<>]/g, '')}:${f.argChoices ? `(${f.argChoices.join(' ')})` : '_files'}` : ''
-    const repeat = Array.isArray(f.defaultValue) ? '*' : ''
-    return `    '${repeat}${f.long}[${desc}]${value}'`
-  }).join('\n')
-
-  return `#compdef ${NAME}
-
-${fn}() {
-  local -a verbs
-  verbs=(
-${zshVerbs}
-  )
-  _arguments -s \\
-${zshFlags} \\
-    '1: :{_describe verb verbs}' \\
-    '*:: :->rest'
-}
-
-${fn} "$@"
-`
-}

package/src/cli/output.ts

@@ -1,246 +0,0 @@
-import { closeSync, existsSync, lstatSync, mkdirSync, openSync, readdirSync, rmSync, symlinkSync, unlinkSync, writeSync } from 'node:fs'
-import { basename, join, resolve } from 'node:path'
-import type { Readable } from 'node:stream'
-import { containerName } from '../docker/spec'
-import { staleWarning } from '../mods/staleness'
-import type { LaunchPlan, Problem, ResolvedMod } from '../types'
-import { Exit } from '../types'
-
-/** Tool status. Never stdout: stdout belongs to the game. */
-export function status(message: string): void {
-  process.stderr.write(line(message))
-}
-
-export function warn(message: string): void {
-  process.stderr.write(line(`warning: ${message}`))
-}
-
-export interface OutputRedirect {
-  close(): void
-}
-
-export function redirectOutput(path: string): OutputRedirect {
-  const fd = openSync(path, 'w')
-  const stdout = process.stdout.write
-  const stderr = process.stderr.write
-  let open = true
-  const write = ((
-    chunk: string | Uint8Array,
-    encodingOrCallback?: BufferEncoding | (() => void),
-    callback?: () => void,
-  ) => {
-    append(fd, chunk)
-    const done = typeof encodingOrCallback === 'function' ? encodingOrCallback : callback
-    done?.()
-    return true
-  }) as typeof process.stdout.write
-  process.stdout.write = write
-  process.stderr.write = write
-
-  return {
-    close() {
-      if (!open) return
-      open = false
-      process.stdout.write = stdout
-      process.stderr.write = stderr
-      closeSync(fd)
-    },
-  }
-}
-
-export async function forwardOutput(stream: Readable, target: NodeJS.WriteStream): Promise<void> {
-  for await (const chunk of stream) target.write(chunk as Buffer)
-}
-
-function line(message: string): string {
-  return message.endsWith('\n') ? message : `${message}\n`
-}
-
-/**
- * Every collected failure at once, grouped by location. Resolution stops before any
- * side effect, so reporting the first problem only would hide the rest.
- */
-export function reportProblems(problems: Problem[]): never {
-  if (problems.length === 0) {
-    process.stderr.write(line('resolution failed with no reported detail'))
-    process.exit(Exit.Resolution)
-  }
-
-  const groups = new Map<string, Problem[]>()
-  for (const problem of problems) {
-    const group = groups.get(problem.where)
-    if (group) group.push(problem)
-    else groups.set(problem.where, [problem])
-  }
-
-  const out = [`${problems.length} problem${problems.length === 1 ? '' : 's'}:`]
-  for (const [where, group] of groups) {
-    out.push(`  ${where}`)
-    for (const problem of group) {
-      out.push(`    ${problem.message}`)
-      if (problem.suggestion) out.push(`      did you mean ${problem.suggestion}?`)
-    }
-  }
-  process.stderr.write(`${out.join('\n')}\n`)
-  process.exit(Exit.Resolution)
-}
-
-export interface PlanModPayload {
-  packageId: string
-  kind: ResolvedMod['kind']
-  hostDir: string
-  containerDir: string
-  origin: 'explicit' | 'auto'
-  stale: boolean
-  staleReport?: ResolvedMod['staleReport']
-  workshopId?: number
-}
-
-export interface PlanPayload {
-  game: string
-  profile: string
-  instance?: string
-  mode: string
-  marker?: string
-  timeoutSeconds: number
-  renderWaitSeconds: number
-  profileDir: string
-  instanceDir: string
-  containerName: string
-  dataDirHost: string
-  stageDirHost: string
-  logsDirHost: string
-  mods: PlanModPayload[]
-  warnings: string[]
-}
-
-/**
- * Regenerated from the mods rather than stored, because a successful `--build` clears a stale
- * report and the warning has to disappear with it.
- */
-export function planWarnings(plan: LaunchPlan): string[] {
-  if (!plan.warnOnStale) return plan.warnings
-  const stale = plan.mods
-    .filter((mod) => mod.staleReport !== undefined)
-    .map((mod) => staleWarning(mod.packageId, mod.staleReport!))
-  return [...plan.warnings, ...stale]
-}
-
-/** The `--print-plan --json` payload. Bind mounts leave no host-readable link to assert on. */
-export function planPayload(plan: LaunchPlan): PlanPayload {
-  return {
-    game: plan.game,
-    profile: plan.profile,
-    ...(plan.instance === undefined ? {} : { instance: plan.instance }),
-    mode: plan.mode,
-    ...(plan.marker === undefined ? {} : { marker: plan.marker }),
-    timeoutSeconds: plan.timeoutSeconds,
-    renderWaitSeconds: plan.renderWaitSeconds,
-    profileDir: resolve(plan.profileDir),
-    instanceDir: resolve(plan.instanceDir),
-    containerName: containerName(plan),
-    dataDirHost: resolve(plan.dataDirHost),
-    stageDirHost: resolve(plan.stageDirHost),
-    logsDirHost: resolve(plan.logsDirHost),
-    mods: plan.mods.map((mod) => ({
-      packageId: mod.packageId,
-      kind: mod.kind,
-      hostDir: resolve(mod.hostDir),
-      containerDir: mod.containerDir,
-      origin: mod.explicit ? 'explicit' : 'auto',
-      stale: mod.stale === true,
-      ...(mod.staleReport === undefined ? {} : { staleReport: mod.staleReport }),
-      ...(mod.workshopId === undefined ? {} : { workshopId: mod.workshopId }),
-    })),
-    warnings: planWarnings(plan),
-  }
-}
-
-export function printPlan(plan: LaunchPlan, asJson: boolean): void {
-  const payload = planPayload(plan)
-  if (asJson) {
-    process.stdout.write(`${JSON.stringify(payload, null, 2)}\n`)
-    return
-  }
-
-  const title = payload.instance === undefined
-    ? `${payload.game} ${payload.profile} (${payload.mode})`
-    : `${payload.game} ${payload.profile} / ${payload.instance} (${payload.mode})`
-  const out = [
-    title,
-    `  profile   ${payload.profileDir}`,
-    `  instance  ${payload.instanceDir}`,
-    `  container ${payload.containerName}`,
-    `  data      ${payload.dataDirHost}`,
-    `  stage     ${payload.stageDirHost}`,
-    `  logs      ${payload.logsDirHost}`,
-  ]
-  if (payload.marker !== undefined) out.push(`  marker    ${payload.marker}`)
-  out.push(`  timeout   ${payload.timeoutSeconds}s, render wait ${payload.renderWaitSeconds}s`)
-  out.push(`  mods      ${payload.mods.length}`)
-
-  const width = Math.max(0, ...payload.mods.map((m) => m.packageId.length))
-  for (const mod of payload.mods) {
-    const notes: string[] = [mod.kind, mod.origin]
-    if (mod.stale) notes.push('stale')
-    out.push(`    ${mod.packageId.padEnd(width)}  ${notes.join(' ')}  ${mod.hostDir} -> ${mod.containerDir}`)
-  }
-  for (const warning of payload.warnings) out.push(`  warning: ${warning}`)
-  process.stdout.write(`${out.join('\n')}\n`)
-}
-
-/** Sortable lexicographically and safe on every filesystem: 20260730T142335123Z. */
-export function runTimestamp(now: Date = new Date()): string {
-  return now.toISOString().replace(/[-:.]/g, '')
-}
-
-/** Makes <logsDir>/runs/<ts>, repoints `current` at it, rotates the old ones, returns the dir. */
-export function openRunLog(logsDir: string, now?: Date): string {
-  const runsDir = join(logsDir, 'runs')
-  mkdirSync(runsDir, { recursive: true })
-
-  const dir = uniqueRunDir(runsDir, runTimestamp(now))
-  mkdirSync(dir)
-  linkCurrent(logsDir, dir)
-  rotateRuns(logsDir, 10)
-  return dir
-}
-
-const encoder = new TextEncoder()
-
-function append(fd: number, chunk: string | Uint8Array): void {
-  writeSync(fd, typeof chunk === 'string' ? encoder.encode(chunk) : chunk)
-}
-
-function uniqueRunDir(runsDir: string, stamp: string): string {
-  let candidate = join(runsDir, stamp)
-  for (let n = 2; existsSync(candidate); n++) candidate = join(runsDir, `${stamp}-${n}`)
-  return candidate
-}
-
-function linkCurrent(logsDir: string, target: string): void {
-  const link = join(logsDir, 'current')
-  try {
-    lstatSync(link)
-    unlinkSync(link)
-  } catch {
-    // No previous link; nothing to clear.
-  }
-  symlinkSync(join('runs', basename(target)), link, 'dir')
-}
-
-/** Landmine 7: a 180MB Player-prev.log was 68% of a profile tree. Retention is the cap. */
-export function rotateRuns(logsDir: string, keep: number): string[] {
-  const runsDir = join(logsDir, 'runs')
-  if (keep < 1 || !existsSync(runsDir)) return []
-
-  const dirs = readdirSync(runsDir, { withFileTypes: true })
-    .filter((entry) => entry.isDirectory())
-    .map((entry) => entry.name)
-    .sort()
-    .reverse()
-
-  const removed = dirs.slice(keep)
-  for (const name of removed) rmSync(join(runsDir, name), { recursive: true, force: true })
-  return removed
-}

package/src/config/builtin.ts

@@ -1,19 +0,0 @@
-import type { Settings } from '../types'
-
-export const DEFAULT_DATA_ROOT = '~/.local/share/gamecrate'
-
-export const DEFAULT_SETTINGS: Settings = {
-  width: 1920,
-  height: 1080,
-  devMode: true,
-  runInBackground: true,
-  resetModsConfigOnCrash: false,
-  gpu: true,
-  audio: true,
-  input: false,
-  network: 'bridge',
-  display: 'x11',
-  memory: '8g',
-  cpus: 6,
-  pidsLimit: 1024,
-}

package/src/config/jsonc.ts

@@ -1,21 +0,0 @@
-import { parse, printParseErrorCode } from 'jsonc-parser'
-import type { ParseError } from 'jsonc-parser'
-import { GamecrateError, Exit } from '../types'
-
-/**
- * JSON with line and block comments and trailing commas. jsonc-parser recovers from
- * syntax errors and still returns a value, so the error list is the only success signal.
- */
-export function parseJsonc(text: string): unknown {
-  const errors: ParseError[] = []
-  const value = parse(text, errors, { allowTrailingComma: true, allowEmptyContent: false })
-  const first = errors[0]
-  if (first !== undefined) {
-    throw new GamecrateError(
-      'config is not valid JSON',
-      Exit.Config,
-      `${printParseErrorCode(first.error)} at offset ${first.offset}`,
-    )
-  }
-  return value
-}