@shigureni/minion 0.1.0 → 0.3.0

package/lib/minion.ts

@@ -0,0 +1,194 @@
+import { homedir } from "node:os"
+import { join } from "node:path"
+import { fileURLToPath } from "node:url"
+import type { MinionFileSystem } from "@lib/engine/fs/file-system"
+import { MemoryMinionFileSystem } from "@lib/engine/fs/memory-file-system"
+import { NodeMinionFileSystem } from "@lib/engine/fs/node-file-system"
+import type { MinionProcessRunner } from "@lib/engine/process/process-runner"
+import { MemoryMinionProcessRunner } from "@lib/engine/process/memory-process-runner"
+import { NodeMinionProcessRunner } from "@lib/engine/process/node-process-runner"
+import type { MinionClock } from "@lib/engine/time/clock"
+import { MemoryMinionClock } from "@lib/engine/time/memory-clock"
+import { NodeMinionClock } from "@lib/engine/time/node-clock"
+import type { MinionRandomSource } from "@lib/engine/random/random-source"
+import { MemoryMinionRandomSource } from "@lib/engine/random/memory-random-source"
+import { NodeMinionRandomSource } from "@lib/engine/random/node-random-source"
+import { type MinionPaths, resolveMinionPaths } from "@lib/engine/app/app-paths"
+import { type MinionAppEvent, MinionAppRunner } from "@lib/engine/app/app-runner"
+import { MinionConfigStore } from "@lib/engine/config/config-store"
+import type { Achievement } from "@lib/engine/collection/achievements"
+import { MinionCollectionStore } from "@lib/engine/collection/collection-store"
+import { MinionCollectionTracker } from "@lib/engine/collection/collection-tracker"
+import type { MinionSpecies } from "@lib/engine/collection/species"
+import { MinionGatewayServer } from "@lib/engine/gateway/gateway-server"
+import { resolveGatewayDaemonScript } from "@lib/engine/gateway/resolve-daemon-script"
+import { SessionStatsTracker } from "@lib/engine/stats/session-stats-tracker"
+import { TokenUsageTracker } from "@lib/engine/stats/token-usage-tracker"
+import { MinionStatsCollector } from "@lib/engine/stats/stats-collector"
+
+const SANDBOX_PACKAGE_ROOT = "/sandbox/pkg"
+const SANDBOX_DATA_DIR = "/sandbox/.minion"
+const SANDBOX_SESSIONS_DIR = "/sandbox/.claude/sessions"
+const SANDBOX_PROJECTS_DIR = "/sandbox/.claude/projects"
+
+export type MinionOptions = {
+  /** Filesystem boundary. Replace with MemoryMinionFileSystem to sandbox all disk I/O. */
+  fs?: MinionFileSystem
+  /** Process runner used to build/spawn the Swift app and the gateway daemon. */
+  process?: MinionProcessRunner
+  /** Clock used for session-staleness checks and pet-behavior timing. */
+  clock?: MinionClock
+  /** Randomness used by the pet behavior picker. */
+  random?: MinionRandomSource
+  /** Directory containing `swift/` (the package root). Defaults to the installed package root. */
+  packageRoot?: string
+  /** State directory (pid files, config, build output). Defaults to `~/.minion`. */
+  dataDir?: string
+  /** Directory of Claude Code session files the gateway watches. Defaults to `~/.claude/sessions`. */
+  sessionsDir?: string
+  /** Claude Code's transcript root, scanned for token usage. Defaults to `~/.claude/projects`. */
+  projectsDir?: string
+  /** Minion species catalog for `minion.collection`. Defaults to `DEFAULT_MINION_SPECIES` — pass your own to add species, retheme the built-ins, or attach real image `asset` references. */
+  species?: MinionSpecies[]
+  /** Achievement catalog for `minion.collection`. Defaults to `DEFAULT_ACHIEVEMENTS` — pass your own to replace it entirely. */
+  achievements?: Achievement[]
+  /** Progress events from `minion.app` (build started, ...). Defaults to a no-op — the library never writes to stdout itself. */
+  onEvent?: (event: MinionAppEvent) => void
+}
+
+export type MinionGatewayServerOptions = {
+  port?: number
+  tickMs?: number
+}
+
+/**
+ * Facade that wires every minion facet together and exposes the public surface.
+ *
+ * All side-effecting boundaries (filesystem, process, clock, random) are
+ * injected via Props — passing memory implementations gives a fully
+ * sandboxed Minion that touches no real disk, processes, or wall-clock time.
+ *
+ * @example
+ * ```ts
+ * import { Minion } from "@shigureni/minion"
+ *
+ * const minion = new Minion()
+ * const result = await minion.app.start() // { kind: "started", pid: 123 } | ... | Error
+ * if (result instanceof Error) console.error(result.message)
+ * console.log(minion.app.status().app.running)
+ * ```
+ */
+export class Minion {
+  readonly paths: MinionPaths
+  readonly config: MinionConfigStore
+  readonly app: MinionAppRunner
+  readonly stats: MinionStatsCollector
+  readonly collection: MinionCollectionTracker
+
+  private readonly fs: MinionFileSystem
+  private readonly process: MinionProcessRunner
+  private readonly clock: MinionClock
+  private readonly random: MinionRandomSource
+  private readonly sessionsDir: string
+  private readonly projectsDir: string
+
+  constructor(props: MinionOptions = {}) {
+    const packageRoot = props.packageRoot ?? defaultPackageRoot()
+    const fs = props.fs ?? new NodeMinionFileSystem()
+    const processRunner = props.process ?? new NodeMinionProcessRunner()
+    const clock = props.clock ?? new NodeMinionClock()
+    const random = props.random ?? new NodeMinionRandomSource()
+    const projectsDir = props.projectsDir ?? join(homedir(), ".claude", "projects")
+
+    this.fs = fs
+    this.process = processRunner
+    this.clock = clock
+    this.random = random
+    this.sessionsDir = props.sessionsDir ?? join(homedir(), ".claude", "sessions")
+    this.projectsDir = projectsDir
+
+    this.paths = resolveMinionPaths({ packageRoot, dataDir: props.dataDir })
+
+    this.config = new MinionConfigStore({ fs, path: this.paths.configFile })
+
+    this.app = new MinionAppRunner({
+      fs,
+      process: processRunner,
+      paths: this.paths,
+      gatewayCommand: ["bun", resolveGatewayDaemonScript()],
+      onEvent: props.onEvent,
+    })
+
+    this.stats = new MinionStatsCollector({
+      fs,
+      process: processRunner,
+      clock,
+      sessionsDir: this.sessionsDir,
+      projectsDir,
+      sessionStats: new SessionStatsTracker({ fs, path: this.paths.sessionStatsFile }),
+      tokenUsage: new TokenUsageTracker({
+        fs,
+        clock,
+        path: this.paths.usageScanFile,
+        projectsDir,
+      }),
+    })
+
+    this.collection = new MinionCollectionTracker({
+      store: new MinionCollectionStore({ fs, path: this.paths.collectionFile }),
+      species: props.species,
+      achievements: props.achievements,
+    })
+
+    Object.freeze(this)
+  }
+
+  /**
+   * Sandboxed Minion wired with in-memory implementations for every IO
+   * boundary. Touches no real disk, processes, or wall-clock time — safe
+   * for tests and ad-hoc experiments. Override individual fields via `props`.
+   *
+   * NOT covered by `inMemory()`: `gatewayServer().start()` still calls
+   * `Bun.serve` and binds a real port; pass `port: 0` to let the OS pick one.
+   */
+  static inMemory(props: MinionOptions = {}): Minion {
+    // The default sandbox fs stamps mtimes off the sandbox clock, so
+    // recency-based logic (e.g. the token-scan backfill window) sees one
+    // consistent timeline instead of mixing wall-clock mtimes with a frozen clock.
+    const clock = props.clock ?? new MemoryMinionClock()
+    return new Minion({
+      ...props,
+      fs: props.fs ?? new MemoryMinionFileSystem({ now: () => clock.millis() }),
+      process: props.process ?? new MemoryMinionProcessRunner(),
+      clock,
+      random: props.random ?? new MemoryMinionRandomSource(),
+      packageRoot: props.packageRoot ?? SANDBOX_PACKAGE_ROOT,
+      dataDir: props.dataDir ?? SANDBOX_DATA_DIR,
+      sessionsDir: props.sessionsDir ?? SANDBOX_SESSIONS_DIR,
+      projectsDir: props.projectsDir ?? SANDBOX_PROJECTS_DIR,
+    })
+  }
+
+  /**
+   * In-process gateway server (HTTP + WebSocket) that watches the sessions
+   * directory and drives the pet's animation state. The daemon spawned by
+   * `app.start()` runs this same class out-of-process via `gateway-daemon.ts`.
+   */
+  gatewayServer(options: MinionGatewayServerOptions = {}): MinionGatewayServer {
+    return new MinionGatewayServer({
+      fs: this.fs,
+      process: this.process,
+      clock: this.clock,
+      random: this.random,
+      sessionsDir: this.sessionsDir,
+      projectsDir: this.projectsDir,
+      port: options.port,
+      tickMs: options.tickMs,
+    })
+  }
+}
+
+function defaultPackageRoot(): string {
+  // URL.pathname はパスに空白や非ASCII文字があるとパーセントエンコードされたまま壊れる
+  return fileURLToPath(new URL("..", import.meta.url))
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shigureni/minion",
-  "version": "0.1.0",
+  "version": "0.3.0",
   "description": "Desktop pet that reacts to your Claude Code session activity",
   "keywords": [
     "claude-code",
@@ -15,12 +15,20 @@
   },
   "files": [
     "cli/src",
+    "lib",
     "swift",
     "tsconfig.json",
     "!cli/src/**/*.test.ts",
+    "!lib/**/*.test.ts",
     "!swift/.build"
   ],
   "type": "module",
+  "main": "./lib/index.ts",
+  "types": "./lib/index.ts",
+  "exports": {
+    ".": "./lib/index.ts",
+    "./package.json": "./package.json"
+  },
   "publishConfig": {
     "access": "public"
   },

package/swift/Sources/open-minion/open_minion.swift

@@ -280,6 +280,9 @@ final class Pet {
             window.setFrameOrigin(NSPoint(x: x, y: y))
         }
 
+        // スポーン時の向きはランダム。移動する行動を取るまでこの向きを保つ。
+        facingLeft = Bool.random()
+
         window.orderFrontRegardless()
     }
 
@@ -359,6 +362,7 @@ final class Pet {
         }
 
         // セッションが idle の間は、その場でうずくまって寝る(掴む/なでるはできる)。
+        // ただし待機クリップ自体のコマ送りは止めない。止めると単なる1枚絵で固まって見える。
         let sleeping = !sessionRunning
         if !sleeping {
             if feedTicksRemaining > 0 {
@@ -368,8 +372,8 @@ final class Pet {
                 }
             }
             stepBehavior()
-            advanceAnimationFrame()
         }
+        advanceAnimationFrame()
 
         petView.isAsleep = sleeping
         petView.facingLeft = facingLeft

package/tsconfig.json

@@ -8,8 +8,9 @@
     "skipLibCheck": true,
     "types": ["node", "bun"],
     "paths": {
-      "@/*": ["./cli/src/*"]
+      "@/*": ["./cli/src/*"],
+      "@lib/*": ["./lib/*"]
     }
   },
-  "include": ["cli/src"]
+  "include": ["cli/src", "lib"]
 }

package/cli/src/gateway.ts

@@ -1,204 +0,0 @@
-#!/usr/bin/env bun
-
-import { readdirSync, readFileSync } from "node:fs"
-import { homedir } from "node:os"
-import { join } from "node:path"
-
-const SESSIONS_DIR = join(homedir(), ".claude", "sessions")
-const STALE_MS = 8 * 60 * 1000
-const TICK_MS = 250
-const PORT = Number(process.env.MINION_GATEWAY_PORT) || 4756
-
-// Swift側 PetView.clips と同じ並び順・重み(合計100)。座標や速度はSwiftが持つ
-// clip定義とスクリーン形状に依存するため、ここでは「どの行動を・どれだけ続けるか」だけを決める。
-const ACTIONS: { durationMs: [number, number]; weight: number }[] = [
-  { weight: 14, durationMs: [3000, 6000] }, // 0 待機
-  { weight: 10, durationMs: [3000, 6000] }, // 1 歩く
-  { weight: 28, durationMs: [4000, 7000] }, // 2 走る
-  { weight: 3, durationMs: [1000, 2000] }, // 3 ジャンプ1
-  { weight: 3, durationMs: [1000, 2000] }, // 4 ジャンプ2
-  { weight: 3, durationMs: [1000, 2000] }, // 5 ジャンプ3
-  { weight: 3, durationMs: [1000, 2000] }, // 6 ジャンプ4
-  { weight: 8, durationMs: [4000, 7000] }, // 7 座る1
-  { weight: 8, durationMs: [4000, 7000] }, // 8 座る2
-  { weight: 8, durationMs: [4000, 7000] }, // 9 座る3
-  { weight: 8, durationMs: [4000, 7000] }, // 10 座る4
-  { weight: 2, durationMs: [2000, 3000] }, // 11 食べる1
-  { weight: 2, durationMs: [2000, 3000] }, // 12 食べる2
-]
-const IDLE_CLIP = 0
-
-function pickAction(): { clipIndex: number; durationMs: number } {
-  const roll = Math.random() * 100
-  let cumulative = 0
-  let chosen = IDLE_CLIP
-  for (let i = 0; i < ACTIONS.length; i++) {
-    cumulative += ACTIONS[i].weight
-    if (roll < cumulative) {
-      chosen = i
-      break
-    }
-  }
-  const [min, max] = ACTIONS[chosen].durationMs
-  return { clipIndex: chosen, durationMs: min + Math.random() * (max - min) }
-}
-
-function isPidAlive(pid: number): boolean {
-  try {
-    process.kill(pid, 0)
-    return true
-  } catch {
-    return false
-  }
-}
-
-// updatedAt はステータスが切り替わった時にしか更新されないため、
-// ずっと busy のまま長時間動いているセッションは経過時間だけでは判定できない。
-// プロセスが生きている間は経過時間を無視し、死んでから8分の猶予で消す。
-interface SessionInfo {
-  running: boolean
-  name: string
-}
-
-function readActiveSessions(): Map<string, SessionInfo> {
-  let files: string[]
-  try {
-    files = readdirSync(SESSIONS_DIR).filter((f) => f.endsWith(".json"))
-  } catch {
-    return new Map()
-  }
-
-  const now = Date.now()
-  const result = new Map<string, SessionInfo>()
-
-  for (const file of files) {
-    try {
-      const raw = JSON.parse(readFileSync(join(SESSIONS_DIR, file), "utf8"))
-      if (typeof raw.sessionId !== "string" || typeof raw.pid !== "number") continue
-
-      const alive = isPidAlive(raw.pid)
-      if (!alive) {
-        const updatedAt = raw.updatedAt ?? raw.statusUpdatedAt ?? raw.startedAt
-        if (typeof updatedAt !== "number" || now - updatedAt > STALE_MS) continue
-      }
-
-      result.set(raw.sessionId, {
-        running: alive && raw.status === "busy",
-        name: typeof raw.name === "string" ? raw.name : "",
-      })
-    } catch {
-      // 書き込み途中などで壊れているファイルは無視
-    }
-  }
-
-  return result
-}
-
-interface PetBehavior {
-  running: boolean
-  name: string
-  clipIndex: number
-  actionEndsAt: number
-}
-
-const behaviors = new Map<string, PetBehavior>()
-const clients = new Set()
-
-function snapshot() {
-  return Array.from(behaviors.entries()).map(([id, b]) => ({
-    id,
-    state: b.running ? "running" : "sleeping",
-    clipIndex: b.clipIndex,
-    name: b.name,
-  }))
-}
-
-function broadcast(): void {
-  const payload = JSON.stringify({ sessions: snapshot() })
-  for (const ws of clients) {
-    ;(ws as { send: (data: string) => void }).send(payload)
-  }
-}
-
-function tick(): void {
-  const now = Date.now()
-  const activeSessions = readActiveSessions()
-  let dirty = false
-
-  for (const id of behaviors.keys()) {
-    if (!activeSessions.has(id)) {
-      behaviors.delete(id)
-      dirty = true
-    }
-  }
-
-  for (const [id, info] of activeSessions) {
-    const existing = behaviors.get(id)
-
-    if (!existing) {
-      const action = info.running ? pickAction() : { clipIndex: IDLE_CLIP, durationMs: 0 }
-      behaviors.set(id, {
-        running: info.running,
-        name: info.name,
-        clipIndex: action.clipIndex,
-        actionEndsAt: now + action.durationMs,
-      })
-      dirty = true
-      continue
-    }
-
-    if (existing.name !== info.name) {
-      existing.name = info.name
-      dirty = true
-    }
-
-    if (existing.running !== info.running) {
-      existing.running = info.running
-      if (info.running) {
-        const action = pickAction()
-        existing.clipIndex = action.clipIndex
-        existing.actionEndsAt = now + action.durationMs
-      }
-      dirty = true
-    } else if (info.running && now >= existing.actionEndsAt) {
-      const action = pickAction()
-      existing.clipIndex = action.clipIndex
-      existing.actionEndsAt = now + action.durationMs
-      dirty = true
-    }
-  }
-
-  if (dirty) broadcast()
-}
-
-setInterval(tick, TICK_MS)
-tick()
-
-Bun.serve({
-  port: PORT,
-  fetch(req, server) {
-    const url = new URL(req.url)
-    if (url.pathname === "/sessions") {
-      return Response.json({ sessions: snapshot() })
-    }
-    if (url.pathname === "/ws") {
-      if (server.upgrade(req)) return undefined
-      return new Response("upgrade failed", { status: 400 })
-    }
-    return new Response("not found", { status: 404 })
-  },
-  websocket: {
-    open(ws) {
-      clients.add(ws)
-      ws.send(JSON.stringify({ sessions: snapshot() }))
-    },
-    close(ws) {
-      clients.delete(ws)
-    },
-    message() {
-      // クライアントからのメッセージは使わない
-    },
-  },
-})
-
-console.log(`gateway listening on :${PORT}`)

package/cli/src/lib/process.ts

@@ -1,204 +0,0 @@
-import { createHash } from "node:crypto"
-import {
-  closeSync,
-  existsSync,
-  mkdirSync,
-  openSync,
-  readFileSync,
-  rmSync,
-  writeFileSync,
-} from "node:fs"
-import { homedir } from "node:os"
-import { join } from "node:path"
-
-const PACKAGE_ROOT = join(import.meta.dir, "..", "..", "..")
-const APP_ROOT = join(PACKAGE_ROOT, "swift")
-// bunx はパッケージ本体をキャッシュディレクトリに展開するため、状態とビルド
-// 成果物はパッケージの場所に依存しないよう ~/.minion に置く。
-const DATA_DIR = join(homedir(), ".minion")
-const BUILD_PATH = join(DATA_DIR, "build")
-const BIN_PATH = join(BUILD_PATH, "release", "open-minion")
-const DEBUG_BIN_PATH = join(BUILD_PATH, "debug", "open-minion")
-const DATA_FILE = join(DATA_DIR, "data.json")
-const PID_FILE = join(DATA_DIR, "pid")
-const CONFIG_FILE = join(DATA_DIR, "config.json")
-const GATEWAY_SCRIPT = join(import.meta.dir, "..", "gateway.ts")
-const GATEWAY_PID_FILE = join(DATA_DIR, "gateway.pid")
-
-interface BuildData {
-  sourceHash: string
-}
-
-function computeSourceHash(): string {
-  const files = [
-    join(APP_ROOT, "Package.swift"),
-    ...Array.from(new Bun.Glob("Sources/**/*.swift").scanSync({ cwd: APP_ROOT })).map((f) =>
-      join(APP_ROOT, f),
-    ),
-  ].sort()
-  const hash = createHash("sha256")
-  for (const file of files) {
-    hash.update(readFileSync(file))
-  }
-  return hash.digest("hex")
-}
-
-function readBuildData(): BuildData | null {
-  if (!existsSync(DATA_FILE)) return null
-  try {
-    return JSON.parse(readFileSync(DATA_FILE, "utf8"))
-  } catch {
-    return null
-  }
-}
-
-function writeBuildData(data: BuildData): void {
-  mkdirSync(DATA_DIR, { recursive: true })
-  writeFileSync(DATA_FILE, JSON.stringify(data, null, 2))
-}
-
-function readPid(pidFile: string = PID_FILE): number | null {
-  if (!existsSync(pidFile)) return null
-  const pid = parseInt(readFileSync(pidFile, "utf8").trim(), 10)
-  return Number.isNaN(pid) ? null : pid
-}
-
-function isRunning(pid: number): boolean {
-  try {
-    process.kill(pid, 0)
-    return true
-  } catch {
-    return false
-  }
-}
-
-function acquireStartLock(): boolean {
-  mkdirSync(DATA_DIR, { recursive: true })
-  try {
-    closeSync(openSync(PID_FILE, "wx"))
-    return true
-  } catch {
-    return false
-  }
-}
-
-async function build(debug: boolean): Promise<boolean> {
-  console.log("ビルド中...")
-  const args = debug
-    ? ["swift", "build", "--scratch-path", BUILD_PATH]
-    : ["swift", "build", "-c", "release", "--scratch-path", BUILD_PATH]
-  const proc = Bun.spawn(args, {
-    cwd: APP_ROOT,
-    stdout: "inherit",
-    stderr: "inherit",
-  })
-  const code = await proc.exited
-  if (code !== 0) {
-    console.error("ビルド失敗")
-    return false
-  }
-  return true
-}
-
-function startGateway(): void {
-  const pid = readPid(GATEWAY_PID_FILE)
-  if (pid !== null && isRunning(pid)) return
-
-  mkdirSync(DATA_DIR, { recursive: true })
-  const proc = Bun.spawn(["bun", GATEWAY_SCRIPT], {
-    stdout: "ignore",
-    stderr: "ignore",
-    stdin: "ignore",
-  })
-  proc.unref()
-  writeFileSync(GATEWAY_PID_FILE, String(proc.pid))
-}
-
-function killGateway(): void {
-  const pid = readPid(GATEWAY_PID_FILE)
-  if (pid !== null && isRunning(pid)) {
-    process.kill(pid, "SIGTERM")
-  }
-  rmSync(GATEWAY_PID_FILE, { force: true })
-}
-
-export async function startApp(debug: boolean): Promise<string> {
-  const existingPid = readPid()
-  if (existingPid !== null) {
-    if (isRunning(existingPid)) {
-      return `すでに起動中 (pid ${existingPid})`
-    }
-    rmSync(PID_FILE, { force: true })
-  }
-
-  if (!acquireStartLock()) {
-    return "他の起動処理と競合したため中止"
-  }
-
-  const binPath = debug ? DEBUG_BIN_PATH : BIN_PATH
-
-  if (debug) {
-    if (!(await build(true))) {
-      rmSync(PID_FILE, { force: true })
-      return "ビルド失敗"
-    }
-  } else {
-    const currentHash = computeSourceHash()
-    const buildData = readBuildData()
-    if (!existsSync(binPath) || buildData?.sourceHash !== currentHash) {
-      if (!(await build(false))) {
-        rmSync(PID_FILE, { force: true })
-        return "ビルド失敗"
-      }
-      writeBuildData({ sourceHash: currentHash })
-    }
-  }
-
-  const proc = Bun.spawn([binPath], {
-    cwd: APP_ROOT,
-    stdout: "ignore",
-    stderr: "ignore",
-    stdin: "ignore",
-  })
-  proc.unref()
-  writeFileSync(PID_FILE, String(proc.pid))
-  startGateway()
-  return `起動した (pid ${proc.pid})`
-}
-
-export function killApp(): string {
-  killGateway()
-  const pid = readPid()
-  if (!pid || !isRunning(pid)) {
-    if (existsSync(PID_FILE)) rmSync(PID_FILE, { force: true })
-    return "起動していない"
-  }
-  process.kill(pid, "SIGTERM")
-  rmSync(PID_FILE, { force: true })
-  return `停止した (pid ${pid})`
-}
-
-export function statusApp(): string {
-  const pid = readPid()
-  const appLine = pid && isRunning(pid) ? `起動中 (pid ${pid})` : "停止中"
-
-  const gatewayPid = readPid(GATEWAY_PID_FILE)
-  const gatewayLine =
-    gatewayPid && isRunning(gatewayPid) ? `gateway起動中 (pid ${gatewayPid})` : "gateway停止中"
-
-  return [appLine, gatewayLine].join("\n")
-}
-
-export function readConfig(): Record<string, string> {
-  if (!existsSync(CONFIG_FILE)) return {}
-  try {
-    return JSON.parse(readFileSync(CONFIG_FILE, "utf8"))
-  } catch {
-    return {}
-  }
-}
-
-export function writeConfig(config: Record<string, string>): void {
-  mkdirSync(DATA_DIR, { recursive: true })
-  writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2))
-}