@mohou/host 1.0.20

package/src/files/tools.ts

@@ -0,0 +1,215 @@
+import { mkdir, readdir, readFile, rm, stat, writeFile } from 'node:fs/promises'
+import path from 'node:path'
+
+import { appEntries } from '@mohou/contract'
+
+import { FileToolError } from './codes.ts'
+import { snapshotSkip } from './skip.ts'
+
+/** Names listing never returns. The set is `snapshotSkip`. */
+const SKIP = snapshotSkip
+
+/** Required entries. One table, not a special case for the manifest. */
+const PROTECTED = new Set<string>([appEntries.manifest, appEntries.ui, appEntries.backend])
+
+export interface FileRead {
+  path: string
+  content: string
+  bytes: number
+  totalLines: number
+  startLine: number
+  endLine: number
+  truncated?: boolean
+}
+
+export interface FileCommit {
+  status: 'committed' | 'clean' | 'skipped' | 'failed'
+  reason?: string
+}
+
+/**
+ * Authoring file tools for one app directory. Paths use `/` on every platform.
+ * @param appDir - absolute app directory
+ * @param options - window cap and the history commit, which is not wired here
+ */
+export function createFileTools(appDir: string, options?: {
+  readonly maxLines?: number
+  readonly commit?: (message: string) => Promise<FileCommit>
+  /** Another owner decides. This module does not know why a path is kept. */
+  readonly protectedPath?: (portablePath: string) => boolean
+}) {
+  return {
+    list: () => listFiles(appDir),
+    read: (relative: string, window?: { start?: number; end?: number }, numbered = false) =>
+      readAppFile(appDir, relative, window, numbered, options?.maxLines),
+    edit: (relative: string, edits: Array<{ oldText: string; newText: string }>, commit = true) =>
+      editAppFile(appDir, relative, edits, commit, options?.commit, options?.protectedPath),
+    write: (relative: string, content: string, commit = true) =>
+      writeAppFile(appDir, relative, content, commit, options?.commit, options?.protectedPath),
+    delete: (relative: string, commit = true) =>
+      deleteAppFile(appDir, relative, commit, options?.commit, options?.protectedPath),
+  }
+}
+
+/** Reject an absolute path or `..` on both POSIX and Windows, whatever the host is. */
+export function resolveAppPath(appDir: string, relative: string): string {
+  if (relative === '' || isAbsolute(relative) || relative.split(/[\\/]/).includes('..')) {
+    throw new FileToolError('path-escape', `path escapes the app directory: ${relative}`)
+  }
+  const resolved = path.resolve(appDir, relative)
+  const stayed = path.relative(appDir, resolved)
+  if (stayed.startsWith('..') || path.isAbsolute(stayed)) {
+    throw new FileToolError('path-escape', `path escapes the app directory: ${relative}`)
+  }
+  return resolved
+}
+
+function isAbsolute(value: string): boolean {
+  return path.posix.isAbsolute(value) || path.win32.isAbsolute(value)
+}
+
+async function listFiles(appDir: string): Promise<Array<{ path: string; bytes: number }>> {
+  const out: Array<{ path: string; bytes: number }> = []
+  await walk(appDir, appDir, out)
+  return out
+}
+
+async function walk(appDir: string, current: string, out: Array<{ path: string; bytes: number }>): Promise<void> {
+  const entries = await readdir(current, { withFileTypes: true })
+  for (const entry of entries) {
+    if (SKIP.has(entry.name)) continue
+    const full = path.join(current, entry.name)
+    if (entry.isDirectory()) {
+      await walk(appDir, full, out)
+      continue
+    }
+    if (!entry.isFile()) continue
+    const info = await stat(full)
+    out.push({ path: path.relative(appDir, full).split(path.sep).join('/'), bytes: info.size })
+  }
+}
+
+async function readAppFile(
+  appDir: string,
+  relative: string,
+  window: { start?: number; end?: number } | undefined,
+  numbered: boolean,
+  maxLines: number | undefined,
+): Promise<FileRead> {
+  const full = resolveAppPath(appDir, relative)
+  const info = await stat(full).catch(() => undefined)
+  if (info === undefined) throw new FileToolError('file-missing', `file is missing: ${relative}`)
+  if (info.isDirectory()) throw new FileToolError('path-is-directory', `path is a directory: ${relative}`)
+  const text = await readFile(full, 'utf8')
+  const lines = text.split(/\r?\n/)
+  const totalLines = lines.length
+  const start = window?.start ?? 1
+  const requestedEnd = window?.end ?? totalLines
+  const cappedEnd = maxLines === undefined ? requestedEnd : Math.min(requestedEnd, start + maxLines - 1)
+  const end = Math.min(cappedEnd, totalLines)
+  const slice = lines.slice(Math.max(0, start - 1), end)
+  const content = numbered
+    ? slice.map((line, index) => `${start + index}|${line}`).join('\n')
+    : slice.join('\n')
+  const truncated = end < requestedEnd || end < totalLines && window?.end === undefined && maxLines !== undefined
+  return {
+    path: relative.split(/[\\/]/).join('/'),
+    content,
+    bytes: info.size,
+    totalLines,
+    startLine: start,
+    endLine: end,
+    ...truncated ? { truncated: true } : {},
+  }
+}
+
+async function editAppFile(
+  appDir: string,
+  relative: string,
+  edits: Array<{ oldText: string; newText: string }>,
+  commit: boolean,
+  committer: ((message: string) => Promise<FileCommit>) | undefined,
+  protectedPath: ((portablePath: string) => boolean) | undefined,
+): Promise<{ path: string; commit: FileCommit }> {
+  rejectOwned(relative, protectedPath)
+  const full = resolveAppPath(appDir, relative)
+  let text: string
+  try {
+    text = await readFile(full, 'utf8')
+  } catch {
+    throw new FileToolError('file-missing', `file is missing: ${relative}`)
+  }
+  for (const edit of edits) {
+    const at = text.indexOf(edit.oldText)
+    if (at < 0 || text.indexOf(edit.oldText, at + 1) >= 0) {
+      throw new FileToolError('edit-not-unique', 'oldText is missing or appears more than once')
+    }
+    text = `${text.slice(0, at)}${edit.newText}${text.slice(at + edit.oldText.length)}`
+  }
+  await writeFile(full, text)
+  return { path: relative.split(/[\\/]/).join('/'), commit: await finishCommit(commit, committer, `edit ${relative}`) }
+}
+
+async function writeAppFile(
+  appDir: string,
+  relative: string,
+  content: string,
+  commit: boolean,
+  committer: ((message: string) => Promise<FileCommit>) | undefined,
+  protectedPath: ((portablePath: string) => boolean) | undefined,
+): Promise<{ path: string; commit: FileCommit }> {
+  rejectOwned(relative, protectedPath)
+  const full = resolveAppPath(appDir, relative)
+  const info = await stat(full).catch(() => undefined)
+  if (info?.isDirectory()) throw new FileToolError('path-is-directory', `path is a directory: ${relative}`)
+  await mkdir(path.dirname(full), { recursive: true })
+  await writeFile(full, content)
+  return { path: relative.split(/[\\/]/).join('/'), commit: await finishCommit(commit, committer, `write ${relative}`) }
+}
+
+async function deleteAppFile(
+  appDir: string,
+  relative: string,
+  commit: boolean,
+  committer: ((message: string) => Promise<FileCommit>) | undefined,
+  protectedPath: ((portablePath: string) => boolean) | undefined,
+): Promise<{ path: string; commit: FileCommit }> {
+  rejectProtected(relative, protectedPath)
+  const full = resolveAppPath(appDir, relative)
+  try {
+    await rm(full)
+  } catch {
+    throw new FileToolError('file-missing', `file is missing: ${relative}`)
+  }
+  return { path: relative.split(/[\\/]/).join('/'), commit: await finishCommit(commit, committer, `delete ${relative}`) }
+}
+
+function rejectOwned(
+  relative: string,
+  protectedPath: ((portablePath: string) => boolean) | undefined,
+): void {
+  const portable = relative.split(/[\/]/).join('/')
+  if (protectedPath?.(portable) === true) {
+    throw new FileToolError('manifest-protected', `required entry cannot be changed: ${portable}`)
+  }
+}
+
+function rejectProtected(
+  relative: string,
+  protectedPath: ((portablePath: string) => boolean) | undefined,
+): void {
+  const portable = relative.split(/[\/]/).join('/')
+  if (PROTECTED.has(portable) || protectedPath?.(portable) === true) {
+    throw new FileToolError('manifest-protected', `required entry cannot be changed: ${portable}`)
+  }
+}
+
+async function finishCommit(
+  commit: boolean,
+  committer: ((message: string) => Promise<FileCommit>) | undefined,
+  message: string,
+): Promise<FileCommit> {
+  if (!commit) return { status: 'skipped' }
+  if (committer === undefined) return { status: 'failed', reason: 'history is not wired' }
+  return committer(message)
+}

package/src/history/codes.ts

@@ -0,0 +1,22 @@
+/** Codes the history implementation emits. */
+
+export const historyCodes = ['history-empty-message', 'history-unknown-commit', 'commit-failed'] as const
+
+/** A failure a caller matches. The message is for a person. */
+export type HistoryCode = (typeof historyCodes)[number]
+
+/** Failure while reading or moving app history. */
+export class HistoryError extends Error {
+  readonly code: HistoryCode
+
+  /**
+   * @param code - one of {@link historyCodes}
+   * @param message - human text; not the match key
+   * @param options - optional `cause`
+   */
+  constructor(code: HistoryCode, message: string, options?: { cause?: unknown }) {
+    super(message, options)
+    this.name = 'HistoryError'
+    this.code = code
+  }
+}

package/src/history/store.ts

@@ -0,0 +1,287 @@
+import fs from 'node:fs'
+import { readFile, readdir } from 'node:fs/promises'
+import path from 'node:path'
+
+import git from 'isomorphic-git'
+
+import type { FileCommit } from '../files/tools.ts'
+import { gitDir, snapshotSkip } from '../files/skip.ts'
+import { HistoryError } from './codes.ts'
+
+/** Host identity for snapshots. Not a person, and not a locked product field. */
+const AUTHOR = { name: 'mini-app', email: 'history@localhost' }
+
+/** List depth when the caller omits one. Host policy, not a locked number. */
+const DEFAULT_LIST_LIMIT = 50
+
+/** Preview length for an owner commit read. Host policy, not a locked number. */
+const PREVIEW_LINES = 40
+
+const SKIP = snapshotSkip
+
+export interface HistoryNode {
+  id: string
+  message: string
+  time: string
+  parentIds: string[]
+}
+
+export interface HistoryTip {
+  name: string
+  commitId: string
+}
+
+/**
+ * Commit the app source snapshot. Storage, history metadata, and `node_modules` stay out.
+ * A clean tree does not create an empty commit.
+ * @param appDir - absolute app directory
+ * @param message - required commit message
+ */
+export async function commitApp(appDir: string, message: string): Promise<FileCommit & { id?: string }> {
+  if (message.trim() === '') throw new HistoryError('history-empty-message', 'history commit message is empty')
+  await ensureRepo(appDir)
+  try {
+    const changed = await stage(appDir)
+    if (!changed) return { status: 'clean' }
+    const id = await git.commit({
+      fs,
+      dir: appDir,
+      message,
+      author: AUTHOR,
+      committer: AUTHOR,
+    })
+    return { status: 'committed', id }
+  } catch (error) {
+    throw new HistoryError('commit-failed', 'history commit failed', { cause: error })
+  }
+}
+
+/** First and latest commit times on `main`. Both are omitted when the repo has no commit. */
+export async function historyBounds(appDir: string): Promise<{ createdAt?: string; updatedAt?: string }> {
+  if (!fs.existsSync(path.join(appDir, gitDir))) return {}
+  const head = await git.resolveRef({ fs, dir: appDir, ref: 'main' }).catch(() => null)
+  if (head === null) return {}
+  const latest = await git.readCommit({ fs, dir: appDir, oid: head })
+  let created = latest
+  let parent = latest.commit.parent[0]
+  const seen = new Set<string>([head])
+  while (parent !== undefined && !seen.has(parent)) {
+    seen.add(parent)
+    created = await git.readCommit({ fs, dir: appDir, oid: parent })
+    parent = created.commit.parent[0]
+  }
+  return {
+    createdAt: commitTime(created.commit.committer.timestamp),
+    updatedAt: commitTime(latest.commit.committer.timestamp),
+  }
+}
+
+/**
+ * List commits on `main` and the backup tips. An empty repo is an empty history.
+ * @param appDir - absolute app directory
+ * @param limit - caller cap; omitted uses host policy
+ */
+export async function listHistory(appDir: string, limit = DEFAULT_LIST_LIMIT): Promise<{
+  head: string | null
+  nodes: HistoryNode[]
+  tips: HistoryTip[]
+}> {
+  if (!fs.existsSync(path.join(appDir, gitDir))) return { head: null, nodes: [], tips: [] }
+  const head = await git.resolveRef({ fs, dir: appDir, ref: 'main' }).catch(() => null)
+  if (head === null) return { head: null, nodes: [], tips: [] }
+  const commits = await git.log({ fs, dir: appDir, ref: 'main', depth: limit })
+  const refs = await git.listRefs({ fs, dir: appDir, filepath: 'refs' })
+  const tips: HistoryTip[] = []
+  for (const name of refs) {
+    const commitId = await git.resolveRef({ fs, dir: appDir, ref: name }).catch(() => undefined)
+    if (commitId !== undefined) tips.push({ name, commitId })
+  }
+  return {
+    head,
+    nodes: commits.map(entry => ({
+      id: entry.oid,
+      message: entry.commit.message.trim(),
+      time: commitTime(entry.commit.committer.timestamp),
+      parentIds: entry.commit.parent,
+    })),
+    tips,
+  }
+}
+
+/**
+ * Make the working tree and `main` match `commitId`. The previous head stays a backup ref.
+ * A tree that already matches does not write a backup ref.
+ * @param appDir - absolute app directory
+ * @param commitId - full commit id, or a ref that resolves to one
+ */
+export async function resetApp(appDir: string, commitId: string): Promise<{
+  head: string
+  backupRef?: string
+  changed: boolean
+  files: string[]
+}> {
+  await ensureRepo(appDir)
+  const target = await resolveCommit(appDir, commitId)
+  const previous = await git.resolveRef({ fs, dir: appDir, ref: 'HEAD' }).catch(() => undefined)
+  const changedRows = await diffAgainst(appDir, target)
+  const headMoves = previous !== undefined && previous !== target
+  if (changedRows.length === 0 && !headMoves) {
+    return { head: target, changed: false, files: [] }
+  }
+  let backupRef: string | undefined
+  if (previous !== undefined) {
+    backupRef = `refs/mini-app/backup/${previous}`
+    await git.writeRef({ fs, dir: appDir, ref: backupRef, value: previous, force: true })
+  }
+  const headFiles = previous === undefined ? [] : await git.listFiles({ fs, dir: appDir, ref: previous })
+  const targetFiles = new Set(await git.listFiles({ fs, dir: appDir, ref: target }))
+  const files = [...new Set([
+    ...changedRows,
+    ...headFiles.filter(file => !targetFiles.has(file) && !skipped(file)),
+  ])]
+  await git.checkout({ fs, dir: appDir, ref: target, force: true })
+  return {
+    head: target,
+    ...backupRef === undefined ? {} : { backupRef },
+    changed: true,
+    files,
+  }
+}
+
+/**
+ * Owner read of one commit. The preview is not every changed line.
+ * @param appDir - absolute app directory
+ * @param commitId - full commit id
+ */
+export async function readAppCommit(appDir: string, commitId: string): Promise<{
+  message: string
+  time: string
+  parentIds: string[]
+  files: Array<{ path: string; add: number; del: number; preview: string }>
+}> {
+  const oid = await resolveCommit(appDir, commitId)
+  const commit = await git.readCommit({ fs, dir: appDir, oid })
+  const parent = commit.commit.parent[0]
+  const current = await git.listFiles({ fs, dir: appDir, ref: oid })
+  const previous = parent === undefined ? [] : await git.listFiles({ fs, dir: appDir, ref: parent })
+  const paths = [...new Set([...current, ...previous])].filter(file => !skipped(file)).sort()
+  const files = []
+  for (const file of paths) {
+    const after = current.includes(file) ? await blobText(appDir, oid, file) : ''
+    const before = parent !== undefined && previous.includes(file) ? await blobText(appDir, parent, file) : ''
+    const counted = lineCounts(before, after)
+    if (counted.add === 0 && counted.del === 0) continue
+    files.push({ path: file, ...counted })
+  }
+  return {
+    message: commit.commit.message.trim(),
+    time: new Date(commit.commit.committer.timestamp * 1000).toISOString(),
+    parentIds: commit.commit.parent,
+    files,
+  }
+}
+
+async function ensureRepo(appDir: string): Promise<void> {
+  if (fs.existsSync(path.join(appDir, gitDir))) return
+  await git.init({ fs, dir: appDir, defaultBranch: 'main' })
+}
+
+async function stage(appDir: string): Promise<boolean> {
+  const head = await git.resolveRef({ fs, dir: appDir, ref: 'HEAD' }).catch(() => undefined)
+  const allTracked = head === undefined ? [] : await git.listFiles({ fs, dir: appDir, ref: head })
+  const tracked = allTracked.filter(file => !skipped(file))
+  const disk = await walk(appDir)
+  let changed = false
+  for (const file of disk) {
+    const current = await readFile(filePath(appDir, file))
+    const previous = head === undefined || !tracked.includes(file)
+      ? undefined
+      : await git.readBlob({ fs, dir: appDir, oid: head, filepath: file })
+    if (previous === undefined || !Buffer.from(previous.blob).equals(current)) {
+      await git.add({ fs, dir: appDir, filepath: file })
+      changed = true
+    }
+  }
+  for (const file of allTracked) {
+    if (!skipped(file) && disk.includes(file)) continue
+    await git.remove({ fs, dir: appDir, filepath: file })
+    changed = true
+  }
+  return changed
+}
+
+async function diffAgainst(appDir: string, oid: string): Promise<string[]> {
+  const tracked = (await git.listFiles({ fs, dir: appDir, ref: oid })).filter(file => !skipped(file))
+  const disk = new Set(await walk(appDir))
+  const files: string[] = []
+  for (const file of tracked) {
+    if (!disk.has(file)) {
+      files.push(file)
+      continue
+    }
+    const blob = await git.readBlob({ fs, dir: appDir, oid, filepath: file })
+    const current = await readFile(filePath(appDir, file))
+    if (!Buffer.from(blob.blob).equals(current)) files.push(file)
+  }
+  return files
+}
+
+function filePath(appDir: string, file: string): string {
+  return path.join(appDir, ...file.split('/'))
+}
+
+async function resolveCommit(appDir: string, commitId: string): Promise<string> {
+  try {
+    return await git.resolveRef({ fs, dir: appDir, ref: commitId })
+  } catch (error) {
+    throw new HistoryError('history-unknown-commit', `unknown commit: ${commitId}`, { cause: error })
+  }
+}
+
+async function blobText(appDir: string, oid: string, filepath: string): Promise<string> {
+  const blob = await git.readBlob({ fs, dir: appDir, oid, filepath })
+  return new TextDecoder().decode(blob.blob)
+}
+
+function lineCounts(before: string, after: string): { add: number; del: number; preview: string } {
+  const oldLines = before === '' ? [] : before.split('\n')
+  const nextLines = after === '' ? [] : after.split('\n')
+  const bag = new Map<string, number>()
+  for (const line of oldLines) bag.set(line, (bag.get(line) ?? 0) + 1)
+  let add = 0
+  let del = 0
+  const preview: string[] = []
+  for (const line of nextLines) {
+    const left = bag.get(line) ?? 0
+    if (left > 0) bag.set(line, left - 1)
+    else {
+      add += 1
+      if (preview.length < PREVIEW_LINES) preview.push(`+${line}`)
+    }
+  }
+  for (const [line, count] of bag) {
+    del += count
+    for (let index = 0; index < count && preview.length < PREVIEW_LINES; index += 1) preview.push(`-${line}`)
+  }
+  return { add, del, preview: preview.join('\n') }
+}
+
+function commitTime(seconds: number): string {
+  return new Date(seconds * 1000).toISOString()
+}
+
+async function walk(dir: string, root = dir): Promise<string[]> {
+  const entries = await readdir(dir, { withFileTypes: true }).catch(() => [])
+  const files: string[] = []
+  for (const entry of entries) {
+    if (SKIP.has(entry.name)) continue
+    const full = path.join(dir, entry.name)
+    if (entry.isDirectory()) files.push(...await walk(full, root))
+    else files.push(path.relative(root, full).split(path.sep).join('/'))
+  }
+  return files
+}
+
+function skipped(filepath: string): boolean {
+  return filepath.split('/').some(part => SKIP.has(part))
+}

package/src/host/activity.ts

@@ -0,0 +1,110 @@
+import { mkdirSync, readFileSync, writeFileSync } from 'node:fs'
+
+import type { HeatValue } from './heat.ts'
+import { hostActivityPath } from './layout.ts'
+
+/** The activity file is present and not this shape. The file is left as it is. */
+export class ActivityError extends Error {
+  readonly code: 'activity-invalid' | 'activity-unreadable'
+
+  /**
+   * @param code - `activity-invalid` is a bad document; `activity-unreadable` is a present file that cannot be read
+   * @param message - human text
+   * @param options - optional `cause`
+   */
+  constructor(code: 'activity-invalid' | 'activity-unreadable', message: string, options?: { cause?: unknown }) {
+    super(message, options)
+    this.name = 'ActivityError'
+    this.code = code
+  }
+}
+
+/** One app's usage. Further fields can sit beside the count and the time. */
+export interface ActivityApp extends HeatValue {}
+
+/** Usage on this machine. Not source history, and not `host.json`. */
+export interface Activity {
+  readonly apps: Readonly<Record<string, ActivityApp>>
+}
+
+/**
+ * Read `activity.json`. A missing file is no activity.
+ * A bad document fails and is not an empty map.
+ * @param runtimeRoot - host runtime root
+ */
+export function readActivity(runtimeRoot: string): Activity {
+  let text: string
+  try {
+    text = readFileSync(hostActivityPath(runtimeRoot), 'utf8')
+  } catch (error) {
+    if (isMissing(error)) return { apps: {} }
+    throw new ActivityError('activity-unreadable', 'activity file cannot be read', { cause: error })
+  }
+  return admitActivity(text)
+}
+
+/**
+ * Record one open and write the file. The count increases by one.
+ * `lastOpenedAt` becomes the later of the stored time and `openedAt`.
+ * @param runtimeRoot - host runtime root
+ * @param appId - registered app id
+ * @param openedAt - time of this open
+ */
+export function recordOpen(runtimeRoot: string, appId: string, openedAt: string): Activity {
+  if (appId === '' || openedAt === '') throw new ActivityError('activity-invalid', 'open is missing a field')
+  const current = readActivity(runtimeRoot)
+  const previous = current.apps[appId]
+  const next: Activity = {
+    apps: {
+      ...current.apps,
+      [appId]: {
+        ...previous,
+        openCount: (previous?.openCount ?? 0) + 1,
+        lastOpenedAt: previous !== undefined && previous.lastOpenedAt > openedAt ? previous.lastOpenedAt : openedAt,
+      },
+    },
+  }
+  mkdirSync(runtimeRoot, { recursive: true })
+  writeFileSync(hostActivityPath(runtimeRoot), `${JSON.stringify(next, null, 2)}\n`)
+  return next
+}
+
+function admitActivity(text: string): Activity {
+  let value: unknown
+  try {
+    value = JSON.parse(text)
+  } catch (error) {
+    throw new ActivityError('activity-invalid', 'activity file is not the activity document', { cause: error })
+  }
+  if (!isAppsRecord(value)) throw new ActivityError('activity-invalid', 'activity file is not the activity document')
+  const apps: Record<string, ActivityApp> = {}
+  for (const [appId, app] of Object.entries(value.apps)) {
+    apps[appId] = admitApp(app)
+  }
+  return { apps }
+}
+
+function isAppsRecord(value: unknown): value is { apps: Record<string, unknown> } {
+  return typeof value === 'object'
+    && value !== null
+    && 'apps' in value
+    && typeof value.apps === 'object'
+    && value.apps !== null
+    && !Array.isArray(value.apps)
+}
+
+function admitApp(value: unknown): ActivityApp {
+  if (typeof value !== 'object' || value === null || Array.isArray(value)) {
+    throw new ActivityError('activity-invalid', 'activity app is not an object')
+  }
+  const openCount = 'openCount' in value ? value.openCount : undefined
+  const lastOpenedAt = 'lastOpenedAt' in value ? value.lastOpenedAt : undefined
+  if (typeof openCount !== 'number' || typeof lastOpenedAt !== 'string' || lastOpenedAt === '') {
+    throw new ActivityError('activity-invalid', 'activity is not a count and a time')
+  }
+  return { ...value, openCount, lastOpenedAt }
+}
+
+function isMissing(error: unknown): boolean {
+  return typeof error === 'object' && error !== null && 'code' in error && error.code === 'ENOENT'
+}