oathbound 0.14.0 → 0.15.0

package/config.ts

@@ -1,128 +0,0 @@
-import {
-  writeFileSync, readFileSync, existsSync, mkdirSync,
-} from 'node:fs';
-import { join } from 'node:path';
-
-export type EnforcementLevel = 'warn' | 'registered' | 'audited';
-
-/** Strip // line comments from JSONC, preserving // inside strings. */
-export function stripJsoncComments(text: string): string {
-  let result = '';
-  let i = 0;
-  while (i < text.length) {
-    // String literal — copy through, respecting escapes
-    if (text[i] === '"') {
-      result += '"';
-      i++;
-      while (i < text.length && text[i] !== '"') {
-        if (text[i] === '\\') { result += text[i++]; } // escape char
-        if (i < text.length) { result += text[i++]; }
-      }
-      if (i < text.length) { result += text[i++]; } // closing "
-      continue;
-    }
-    // Line comment
-    if (text[i] === '/' && text[i + 1] === '/') {
-      while (i < text.length && text[i] !== '\n') i++;
-      continue;
-    }
-    result += text[i++];
-  }
-  return result;
-}
-
-export function readOathboundConfig(): { enforcement: EnforcementLevel } | null {
-  const configPath = join(process.cwd(), '.oathbound.jsonc');
-  if (!existsSync(configPath)) return null;
-  try {
-    const raw = readFileSync(configPath, 'utf-8');
-    const parsed = JSON.parse(stripJsoncComments(raw));
-    const level = parsed.enforcement;
-    if (level === 'warn' || level === 'registered' || level === 'audited') {
-      return { enforcement: level };
-    }
-    return { enforcement: 'warn' };
-  } catch {
-    return null;
-  }
-}
-
-export function writeOathboundConfig(enforcement: EnforcementLevel): boolean {
-  const configPath = join(process.cwd(), '.oathbound.jsonc');
-  if (existsSync(configPath)) return false;
-  const content = `// Oathbound project configuration
-// Docs: https://oathbound.ai/docs/config
-{
-  "$schema": "https://oathbound.ai/schemas/config-v1.json",
-  "version": 1,
-  "enforcement": "${enforcement}",
-  "org": null
-}
-`;
-  writeFileSync(configPath, content);
-  return true;
-}
-
-const SKILL_CHECK = { type: 'command', command: 'npx oathbound verify --check' };
-
-const OATHBOUND_HOOKS = {
-  SessionStart: [
-    { matcher: '', hooks: [{ type: 'command', command: 'npx oathbound verify' }] },
-  ],
-  PreToolUse: [
-    { matcher: 'Skill', hooks: [SKILL_CHECK] },
-    { matcher: 'Bash', hooks: [SKILL_CHECK] },
-    { matcher: 'Read', hooks: [SKILL_CHECK] },
-    { matcher: 'Glob', hooks: [SKILL_CHECK] },
-    { matcher: 'Grep', hooks: [SKILL_CHECK] },
-  ],
-};
-
-function hasOathboundHooks(settings: Record<string, unknown>): boolean {
-  const hooks = settings.hooks as Record<string, unknown[]> | undefined;
-  if (!hooks) return false;
-  for (const entries of Object.values(hooks)) {
-    if (!Array.isArray(entries)) continue;
-    for (const entry of entries) {
-      const e = entry as Record<string, unknown>;
-      const innerHooks = e.hooks as Array<Record<string, unknown>> | undefined;
-      if (!innerHooks) continue;
-      for (const h of innerHooks) {
-        if (typeof h.command === 'string' && h.command.startsWith('npx oathbound')) return true;
-      }
-    }
-  }
-  return false;
-}
-
-export type MergeResult = 'created' | 'merged' | 'skipped' | 'malformed';
-
-export function mergeClaudeSettings(): MergeResult {
-  const claudeDir = join(process.cwd(), '.claude');
-  const settingsPath = join(claudeDir, 'settings.json');
-
-  if (!existsSync(settingsPath)) {
-    mkdirSync(claudeDir, { recursive: true });
-    writeFileSync(settingsPath, JSON.stringify({ hooks: OATHBOUND_HOOKS }, null, 2) + '\n');
-    return 'created';
-  }
-
-  let settings: Record<string, unknown>;
-  try {
-    settings = JSON.parse(readFileSync(settingsPath, 'utf-8'));
-  } catch {
-    return 'malformed';
-  }
-
-  if (hasOathboundHooks(settings)) return 'skipped';
-
-  // Merge hooks into existing settings
-  const hooks = (settings.hooks ?? {}) as Record<string, unknown[]>;
-  for (const [event, entries] of Object.entries(OATHBOUND_HOOKS)) {
-    const existing = hooks[event] as unknown[] | undefined;
-    hooks[event] = existing ? [...existing, ...entries] : [...entries];
-  }
-  settings.hooks = hooks;
-  writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + '\n');
-  return 'merged';
-}

package/content-hash.ts

@@ -1,39 +0,0 @@
-import { createHash } from 'node:crypto';
-import { readFileSync, readdirSync } from 'node:fs';
-import { join, relative } from 'node:path';
-
-const HASH_EXCLUDED = new Set([
-  'node_modules',
-  'bun.lock',
-  'package-lock.json',
-  'yarn.lock',
-  '.DS_Store',
-]);
-
-export function collectFiles(dir: string, base: string = dir): { path: string; content: Buffer }[] {
-  const results: { path: string; content: Buffer }[] = [];
-  for (const entry of readdirSync(dir, { withFileTypes: true })) {
-    if (HASH_EXCLUDED.has(entry.name)) continue;
-    const full = join(dir, entry.name);
-    if (entry.isDirectory()) {
-      results.push(...collectFiles(full, base));
-    } else if (entry.isFile()) {
-      results.push({ path: relative(base, full), content: readFileSync(full) });
-    }
-  }
-  return results;
-}
-
-export function contentHash(files: { path: string; content: Buffer }[]): string {
-  const sorted = files.toSorted((a, b) => a.path.localeCompare(b.path));
-  const lines = sorted.map((f) => {
-    const h = createHash('sha256').update(f.content).digest('hex');
-    return `${f.path}\0${h}`;
-  });
-  return createHash('sha256').update(lines.join('\n')).digest('hex');
-}
-
-export function hashSkillDir(skillDir: string): string {
-  const files = collectFiles(skillDir);
-  return contentHash(files);
-}

package/install.cjs

@@ -1,85 +0,0 @@
-#!/usr/bin/env node
-
-// Postinstall script: downloads the correct platform binary from GitHub Releases.
-// Skips download in CI (binaries don't exist yet during the build job).
-
-if (process.env.CI) {
-  console.log("oathbound: skipping binary download in CI");
-  process.exit(0);
-}
-
-const https = require("https");
-const fs = require("fs");
-const path = require("path");
-
-const pkg = require("./package.json");
-const VERSION = pkg.version;
-const REPO = "Joshuatanderson/oath-bound";
-
-const PLATFORM_MAP = {
-  darwin: "darwin",
-  linux: "linux",
-  win32: "windows",
-};
-
-const ARCH_MAP = {
-  arm64: "arm64",
-  x64: "x64",
-};
-
-function getBinaryName() {
-  const platform = PLATFORM_MAP[process.platform];
-  const arch = ARCH_MAP[process.arch];
-  if (!platform || !arch) {
-    throw new Error(
-      `Unsupported platform: ${process.platform}-${process.arch}`
-    );
-  }
-  const ext = process.platform === "win32" ? ".exe" : "";
-  return `oathbound-${platform}-${arch}${ext}`;
-}
-
-function download(url) {
-  return new Promise((resolve, reject) => {
-    https
-      .get(url, (res) => {
-        // Follow redirects (GitHub sends 302 to S3)
-        if (res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
-          return download(res.headers.location).then(resolve, reject);
-        }
-        if (res.statusCode !== 200) {
-          return reject(new Error(`Download failed: HTTP ${res.statusCode} for ${url}`));
-        }
-        const chunks = [];
-        res.on("data", (chunk) => chunks.push(chunk));
-        res.on("end", () => resolve(Buffer.concat(chunks)));
-        res.on("error", reject);
-      })
-      .on("error", reject);
-  });
-}
-
-async function main() {
-  const binaryName = getBinaryName();
-  const url = `https://github.com/${REPO}/releases/download/v${VERSION}/${binaryName}`;
-  const destDir = path.join(__dirname, "bin");
-  const ext = process.platform === "win32" ? ".exe" : "";
-  const dest = path.join(destDir, `oathbound${ext}`);
-
-  console.log(`oathbound: downloading ${binaryName} from v${VERSION} release...`);
-
-  fs.mkdirSync(destDir, { recursive: true });
-
-  const data = await download(url);
-  fs.writeFileSync(dest, data);
-  fs.chmodSync(dest, 0o755);
-
-  console.log(`oathbound: installed to ${dest}`);
-}
-
-main().catch((err) => {
-  console.error(`oathbound install failed: ${err.message}`);
-  console.error("You can download the binary manually from:");
-  console.error(`  https://github.com/${REPO}/releases/tag/v${VERSION}`);
-  process.exit(1);
-});

package/push.ts

@@ -1,133 +0,0 @@
-import { existsSync, statSync } from 'node:fs';
-import { join, basename, resolve } from 'node:path';
-import { intro, outro } from '@clack/prompts';
-import { parse as yamlParse } from 'yaml';
-import { BRAND, GREEN, DIM, BOLD, RESET, fail, spinner } from './ui';
-import { getAccessToken } from './auth';
-import { collectFiles } from './content-hash';
-import { isValidSemver } from './semver';
-
-const API_BASE = process.env.OATHBOUND_API_URL ?? 'https://www.oathbound.ai';
-
-export async function push(pathArg?: string, options?: { private?: boolean }): Promise<void> {
-  intro(BRAND);
-
-  // Resolve skill directory
-  const skillDir = resolveSkillDir(pathArg);
-  console.log(`${DIM}   directory: ${skillDir}${RESET}`);
-
-  // Read and validate SKILL.md exists
-  if (!existsSync(join(skillDir, 'SKILL.md'))) {
-    fail('No SKILL.md found', `Expected at ${join(skillDir, 'SKILL.md')}`);
-  }
-
-  // Collect files
-  const rawFiles = collectFiles(skillDir);
-
-  // Parse SKILL.md frontmatter to extract metadata
-  const skillMdFile = rawFiles.find(f => f.path === 'SKILL.md');
-  if (!skillMdFile) {
-    fail('SKILL.md not found in collected files');
-  }
-
-  const meta = parseFrontmatter(skillMdFile.content.toString('utf-8'));
-  const name = String(meta.name ?? '');
-  const description = String(meta.description ?? '');
-  const license = String(meta.license ?? '');
-  const rawVersion = meta.version != null ? String(meta.version) : null;
-  const version = rawVersion && isValidSemver(rawVersion) ? rawVersion : null;
-  if (!name) fail('SKILL.md frontmatter missing: name');
-  if (!description) fail('SKILL.md frontmatter missing: description');
-  if (!license) fail('SKILL.md frontmatter missing: license');
-
-  const oathboundMeta = (meta.metadata as Record<string, unknown> | undefined)?.oathbound as Record<string, unknown> | undefined;
-  const originalAuthor = String(oathboundMeta?.['original-author'] ?? '');
-
-  // Build files array with root dir prefix (API expects rootDir/path format)
-  const files = rawFiles.map(f => ({
-    path: `${name}/${f.path}`,
-    content: f.content.toString('utf-8'),
-  }));
-
-  console.log(`${DIM}   name: ${name}${RESET}`);
-  console.log(`${DIM}   version: ${version ?? 'auto (next)'}${RESET}`);
-  console.log(`${DIM}   license: ${license}${RESET}`);
-  if (originalAuthor) {
-    console.log(`${DIM}   original author: ${originalAuthor}${RESET}`);
-  }
-  const visibility = options?.private ? 'private' : 'public';
-  if (options?.private) {
-    console.log(`${DIM}   visibility: ${BOLD}private${RESET}`);
-  }
-  console.log(`${DIM}   ${files.length} file(s)${RESET}`);
-
-  // Authenticate
-  const token = await getAccessToken();
-
-  // Push to API
-  const spin = spinner('Pushing...');
-
-  const response = await fetch(`${API_BASE}/api/skills`, {
-    method: 'POST',
-    headers: {
-      'Content-Type': 'application/json',
-      Authorization: `Bearer ${token}`,
-    },
-    body: JSON.stringify({
-      name,
-      description,
-      license,
-      version,
-      compatibility: String(meta.compatibility ?? '') || null,
-      allowedTools: String(meta['allowed-tools'] ?? '') || null,
-      originalAuthor: originalAuthor || null,
-      visibility,
-      files,
-    }),
-  });
-
-  spin.stop();
-
-  if (!response.ok) {
-    const body = await response.json().catch(() => ({ error: 'Unknown error' }));
-    const details = Array.isArray(body.details)
-      ? '\n' + body.details.map((d: string) => `   - ${d}`).join('\n')
-      : '';
-    fail(`Push failed (${response.status})`, `${body.error}${details}`);
-  }
-
-  const result = await response.json();
-
-  outro(`${GREEN}✓ Published ${BOLD}${result.namespace}/${result.name}${RESET}${GREEN} v${result.version}${RESET}`);
-  if (result.suiObjectId) {
-    console.log(`${DIM}   on-chain: ${result.suiObjectId}${RESET}`);
-  }
-}
-
-function resolveSkillDir(pathArg?: string): string {
-  if (pathArg) {
-    const resolved = resolve(pathArg);
-    if (!existsSync(resolved) || !statSync(resolved).isDirectory()) {
-      fail('Invalid path', `${resolved} is not a directory`);
-    }
-    return resolved;
-  }
-
-  // No path given — check if cwd has a SKILL.md
-  if (existsSync(join(process.cwd(), 'SKILL.md'))) {
-    return process.cwd();
-  }
-
-  fail(
-    'No skill directory found',
-    'Run from within a skill directory or pass a path: oathbound push ./my-skill',
-  );
-}
-
-/** Parse YAML frontmatter into a nested object */
-function parseFrontmatter(content: string): Record<string, unknown> {
-  const match = content.match(/^---\s*\n([\s\S]*?)\n---\s*\n/);
-  if (!match) return {};
-  const parsed = yamlParse(match[1]);
-  return typeof parsed === 'object' && parsed !== null ? parsed as Record<string, unknown> : {};
-}

package/search.ts

@@ -1,159 +0,0 @@
-import { BRAND, TEAL, GREEN, DIM, BOLD, RESET, fail, spinner } from './ui';
-
-const API_BASE = process.env.OATHBOUND_API_URL ?? 'https://www.oathbound.ai';
-
-export interface SearchOptions {
-  query?: string;
-  namespace?: string;
-  sparse?: boolean;
-  sort?: 'downloads';
-  limit?: number;
-  offset?: number;
-}
-
-export function parseSearchArgs(args: string[]): SearchOptions {
-  const opts: SearchOptions = {};
-  let i = 0;
-
-  while (i < args.length) {
-    const arg = args[i];
-
-    if (arg === '--user' || arg === '-u') {
-      opts.namespace = args[++i];
-    } else if (arg === '--sparse' || arg === '-s') {
-      opts.sparse = true;
-    } else if (arg === '--sort') {
-      const val = args[++i];
-      if (val === 'downloads') opts.sort = 'downloads';
-    } else if (arg === '--limit') {
-      opts.limit = parseInt(args[++i], 10);
-    } else if (arg === '--offset') {
-      opts.offset = parseInt(args[++i], 10);
-    } else if (!arg.startsWith('-')) {
-      opts.query = arg;
-    }
-
-    i++;
-  }
-
-  return opts;
-}
-
-interface SkillAuthor {
-  username: string;
-  display_name: string | null;
-  verified: boolean;
-}
-
-interface SkillResult {
-  name: string;
-  namespace: string;
-  description: string;
-  version: string;
-  license?: string;
-  visibility?: string;
-  author?: SkillAuthor;
-  audit_status?: 'passed' | 'failed' | 'none';
-  download_count?: number;
-}
-
-interface SearchResponse {
-  ok: boolean;
-  skills: SkillResult[];
-  total: number;
-  limit: number;
-  offset: number;
-  error?: string;
-}
-
-export async function search(opts: SearchOptions): Promise<void> {
-  const params = new URLSearchParams();
-  if (opts.query) params.set('q', opts.query);
-  if (opts.namespace) params.set('namespace', opts.namespace);
-  if (opts.sparse) params.set('sparse', 'true');
-  if (opts.sort) params.set('sort', opts.sort);
-  if (opts.limit != null) params.set('limit', String(opts.limit));
-  if (opts.offset != null) params.set('offset', String(opts.offset));
-
-  const url = `${API_BASE}/api/skills?${params}`;
-
-  const sp = spinner('Searching...');
-
-  let res: Response;
-  try {
-    res = await fetch(url);
-  } catch (err) {
-    sp.stop();
-    const msg = err instanceof Error ? err.message : 'Unknown error';
-    fail('Search failed', msg);
-  }
-
-  sp.stop();
-
-  if (!res.ok) {
-    let detail = `HTTP ${res.status}`;
-    try {
-      const body = await res.json() as { error?: string };
-      if (body.error) detail = body.error;
-    } catch { /* ignore parse errors */ }
-    fail('Search failed', detail);
-  }
-
-  const data = await res.json() as SearchResponse;
-
-  if (!data.ok || !data.skills) {
-    fail('Search failed', data.error ?? 'Unexpected response');
-  }
-
-  const { skills, total, offset } = data;
-
-  if (skills.length === 0) {
-    console.log(`\n${BRAND} ${DIM}No skills found.${RESET}`);
-    return;
-  }
-
-  const showing = offset > 0
-    ? `Showing ${offset + 1}–${offset + skills.length} of ${total}`
-    : `${total} skill${total === 1 ? '' : 's'} found`;
-
-  console.log(`\n${BRAND} ${TEAL}${showing}${RESET}\n`);
-
-  for (const skill of skills) {
-    const id = `${skill.namespace}/${skill.name}`;
-    const ver = `v${skill.version}`;
-
-    // Line 1: name + version
-    console.log(`  ${BOLD}${id}${RESET} ${DIM}${ver}${RESET}`);
-
-    // Line 2: description
-    if (skill.description) {
-      console.log(`  ${DIM}${skill.description}${RESET}`);
-    }
-
-    // Line 3: metadata (non-sparse only)
-    if (!opts.sparse && (skill.author || skill.audit_status || skill.license)) {
-      const parts: string[] = [];
-      if (skill.author) {
-        const name = skill.author.display_name || skill.author.username;
-        parts.push(`by ${name}${skill.author.verified ? ' ✓' : ''}`);
-      }
-      if (skill.license) parts.push(skill.license);
-      if (skill.download_count != null) parts.push(`↓ ${skill.download_count}`);
-      if (skill.audit_status && skill.audit_status !== 'none') {
-        parts.push(skill.audit_status === 'passed' ? `${GREEN}audited${RESET}` : 'audit failed');
-      }
-      if (skill.visibility === 'private') parts.push('private');
-      if (parts.length > 0) {
-        console.log(`  ${DIM}${parts.join(' · ')}${RESET}`);
-      }
-    }
-
-    console.log(); // blank line between skills
-  }
-
-  // Pagination hint
-  if (offset + skills.length < total) {
-    const nextOffset = offset + skills.length;
-    console.log(`${DIM}  Use --offset ${nextOffset} to see more${RESET}\n`);
-  }
-}

package/semver.ts

@@ -1,39 +0,0 @@
-const SEMVER_RE = /^\d+\.\d+\.\d+$/;
-
-export interface SemverParts {
-  major: number;
-  minor: number;
-  patch: number;
-}
-
-/** Parse a semver string into parts. Returns null if invalid. */
-export function parseSemver(version: string): SemverParts | null {
-  if (!SEMVER_RE.test(version)) return null;
-  const [major, minor, patch] = version.split(".").map(Number);
-  return { major, minor, patch };
-}
-
-/** Validate a semver string (MAJOR.MINOR.PATCH). */
-export function isValidSemver(version: string): boolean {
-  return SEMVER_RE.test(version);
-}
-
-/**
- * Compare two semver strings.
- * Returns negative if a < b, 0 if equal, positive if a > b.
- */
-export function compareSemver(a: string, b: string): number {
-  const pa = parseSemver(a);
-  const pb = parseSemver(b);
-  if (!pa || !pb) throw new Error(`Invalid semver: ${!pa ? a : b}`);
-  if (pa.major !== pb.major) return pa.major - pb.major;
-  if (pa.minor !== pb.minor) return pa.minor - pb.minor;
-  return pa.patch - pb.patch;
-}
-
-/** Bump the patch version: "1.2.3" -> "1.2.4" */
-export function bumpPatch(version: string): string {
-  const parts = parseSemver(version);
-  if (!parts) throw new Error(`Invalid semver: ${version}`);
-  return `${parts.major}.${parts.minor}.${parts.patch + 1}`;
-}

package/ui.ts

@@ -1,87 +0,0 @@
-// --- ANSI (respect NO_COLOR standard: https://no-color.org) ---
-export const USE_COLOR = process.env.NO_COLOR === undefined && process.stderr.isTTY;
-export const TEAL = USE_COLOR ? '\x1b[38;2;63;168;164m' : ''; // brand teal #3fa8a4
-export const GREEN = USE_COLOR ? '\x1b[32m' : '';
-export const RED = USE_COLOR ? '\x1b[31m' : '';
-export const YELLOW = USE_COLOR ? '\x1b[33m' : '';
-export const DIM = USE_COLOR ? '\x1b[2m' : '';
-export const BOLD = USE_COLOR ? '\x1b[1m' : '';
-export const RESET = USE_COLOR ? '\x1b[0m' : '';
-
-const BRAND_MARKS = ['✦', '✧', '✿', '⬡'];
-
-export function brand(): string {
-  return `${TEAL}${BOLD}⬡ oathbound${RESET}`;
-}
-
-export const BRAND = brand();
-
-export function usage(exitCode = 1): never {
-  console.log(`
-${BOLD}oathbound${RESET} — install, verify, and publish skills & agents
-
-${DIM}Usage:${RESET}
-  oathbound init                ${DIM}Setup wizard — configure project${RESET}
-  oathbound pull <namespace/skill-name[@version]>
-  oathbound install <namespace/skill-name[@version]>
-  oathbound push [path] [--private]  ${DIM}Publish a skill to the registry${RESET}
-  oathbound search [query]            ${DIM}Search skills in the registry${RESET}
-  oathbound list                      ${DIM}List all public skills${RESET}
-  oathbound login               ${DIM}Authenticate with oathbound.ai${RESET}
-  oathbound logout              ${DIM}Clear stored credentials${RESET}
-  oathbound whoami              ${DIM}Show current user${RESET}
-  oathbound verify              ${DIM}SessionStart hook — verify all skills${RESET}
-  oathbound verify --check      ${DIM}PreToolUse hook — check skill integrity${RESET}
-
-${DIM}Agents:${RESET}
-  oathbound agent push [path] [--private]  ${DIM}Publish an agent .md file${RESET}
-  oathbound agent pull <namespace/name[@version]>
-  oathbound agent search [query]           ${DIM}Search agents in the registry${RESET}
-  oathbound agent list                     ${DIM}List all public agents${RESET}
-
-${DIM}Options:${RESET}
-  --help, -h      Show this help message
-  --version, -v   Show version
-`);
-  process.exit(exitCode);
-}
-
-export function agentUsage(exitCode = 1): never {
-  console.log(`
-${BOLD}oathbound agent${RESET} — manage Claude Code agents
-
-${DIM}Usage:${RESET}
-  oathbound agent push [path] [--private]  ${DIM}Publish an agent .md file to the registry${RESET}
-  oathbound agent pull <namespace/name[@version]>  ${DIM}Download agent to .claude/agents/${RESET}
-  oathbound agent search [query]           ${DIM}Search agents in the registry${RESET}
-  oathbound agent list                     ${DIM}List all public agents${RESET}
-
-${DIM}Options:${RESET}
-  --help, -h      Show this help message
-`);
-  process.exit(exitCode);
-}
-
-export function fail(message: string, detail?: string): never {
-  console.log(`\n${BOLD}${RED} ✗ ${message}${RESET}`);
-  if (detail) {
-    console.log(`${RED}   ${detail}${RESET}`);
-  }
-  process.exit(1);
-}
-
-export function spinner(text: string): { stop: () => void } {
-  let i = 0;
-  const render = () => `\r${TEAL}${BOLD} ${BRAND_MARKS[i % BRAND_MARKS.length]} ${RESET}${TEAL}${text}${RESET}`;
-  process.stdout.write(render());
-  const interval = setInterval(() => {
-    i++;
-    process.stdout.write(render());
-  }, 150);
-  return {
-    stop() {
-      clearInterval(interval);
-      process.stdout.write(USE_COLOR ? '\r\x1b[2K' : '\n');
-    },
-  };
-}