@cuongtran001/kanna 1.63.2 → 1.63.3

package/src/server/claude-pty/pty-memory-sampler.adapter.test.ts

@@ -1,103 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import process from "node:process"
-import {
-  collectTreePids,
-  parsePsOutput,
-  sampleProcessTreeUsage,
-  sumTreeUsage,
-  type PsProcessRow,
-} from "./pty-memory-sampler.adapter"
-
-describe("parsePsOutput", () => {
-  test("parses normal ps output with pid/ppid/rss/pcpu", () => {
-    const out = [
-      "    1     0    1024   0.0",
-      "  100     1    2048   5.2",
-      "  101   100    4096  12.5",
-      "",
-      "  102   100    8192  99.9",
-    ].join("\n")
-    expect(parsePsOutput(out)).toEqual([
-      { pid: 1, ppid: 0, rssKb: 1024, cpuPercent: 0.0 },
-      { pid: 100, ppid: 1, rssKb: 2048, cpuPercent: 5.2 },
-      { pid: 101, ppid: 100, rssKb: 4096, cpuPercent: 12.5 },
-      { pid: 102, ppid: 100, rssKb: 8192, cpuPercent: 99.9 },
-    ])
-  })
-
-  test("skips malformed rows without throwing", () => {
-    const out = [
-      "100 1 1024 3.0",
-      "garbage line here",
-      "abc def ghi jkl",
-      "200 1 2048 7.5",
-      " ",
-      "300 1 100",
-    ].join("\n")
-    expect(parsePsOutput(out)).toEqual([
-      { pid: 100, ppid: 1, rssKb: 1024, cpuPercent: 3.0 },
-      { pid: 200, ppid: 1, rssKb: 2048, cpuPercent: 7.5 },
-    ])
-  })
-
-  test("returns empty array for empty input", () => {
-    expect(parsePsOutput("")).toEqual([])
-    expect(parsePsOutput("\n\n\n")).toEqual([])
-  })
-})
-
-describe("collectTreePids", () => {
-  const rows: PsProcessRow[] = [
-    { pid: 1, ppid: 0, rssKb: 0, cpuPercent: 0 },
-    { pid: 100, ppid: 1, rssKb: 0, cpuPercent: 0 },
-    { pid: 101, ppid: 100, rssKb: 0, cpuPercent: 0 },
-    { pid: 102, ppid: 100, rssKb: 0, cpuPercent: 0 },
-    { pid: 103, ppid: 101, rssKb: 0, cpuPercent: 0 },
-    { pid: 200, ppid: 1, rssKb: 0, cpuPercent: 0 },
-  ]
-
-  test("collects root + descendants transitively", () => {
-    expect(collectTreePids(rows, 100)).toEqual(new Set([100, 101, 102, 103]))
-  })
-
-  test("returns only root when no children", () => {
-    expect(collectTreePids(rows, 200)).toEqual(new Set([200]))
-  })
-
-  test("returns only root when root absent from rows", () => {
-    expect(collectTreePids(rows, 999)).toEqual(new Set([999]))
-  })
-})
-
-describe("sumTreeUsage", () => {
-  const rows: PsProcessRow[] = [
-    { pid: 1, ppid: 0, rssKb: 100, cpuPercent: 1.0 },
-    { pid: 100, ppid: 1, rssKb: 200, cpuPercent: 25.0 },
-    { pid: 101, ppid: 100, rssKb: 300, cpuPercent: 50.5 },
-  ]
-
-  test("sums rss (kb->bytes) + cpu for pids in tree", () => {
-    const tree = new Set<number>([100, 101])
-    expect(sumTreeUsage(rows, tree)).toEqual({
-      rssBytes: (200 + 300) * 1024,
-      cpuPercent: 25.0 + 50.5,
-    })
-  })
-
-  test("returns zeros for empty tree", () => {
-    expect(sumTreeUsage(rows, new Set())).toEqual({ rssBytes: 0, cpuPercent: 0 })
-  })
-})
-
-describe("sampleProcessTreeUsage", () => {
-  test("returns positive rss + finite cpu for current process", async () => {
-    const sample = await sampleProcessTreeUsage(process.pid)
-    expect(sample).not.toBeNull()
-    expect(sample?.rssBytes).toBeGreaterThan(0)
-    expect(Number.isFinite(sample?.cpuPercent ?? Number.NaN)).toBe(true)
-  }, 5_000)
-
-  test("returns null for pid that does not exist", async () => {
-    expect(await sampleProcessTreeUsage(2_147_483_646)).toBeNull()
-  }, 5_000)
-})

package/src/server/claude-pty/pty-memory-sampler.adapter.ts

@@ -1,86 +0,0 @@
-import { execFile } from "node:child_process"
-import { promisify } from "node:util"
-
-const execFileAsync = promisify(execFile)
-
-const PS_TIMEOUT_MS = 2000
-
-export interface PsProcessRow {
-  pid: number
-  ppid: number
-  rssKb: number
-  cpuPercent: number
-}
-
-export interface ProcessTreeSample {
-  rssBytes: number
-  cpuPercent: number
-}
-
-export function parsePsOutput(stdout: string): PsProcessRow[] {
-  const rows: PsProcessRow[] = []
-  for (const rawLine of stdout.split("\n")) {
-    const line = rawLine.trim()
-    if (!line) continue
-    const parts = line.split(/\s+/)
-    if (parts.length < 4) continue
-    const pid = Number(parts[0])
-    const ppid = Number(parts[1])
-    const rssKb = Number(parts[2])
-    const cpuPercent = Number(parts[3])
-    if (!Number.isFinite(pid) || !Number.isFinite(ppid) || !Number.isFinite(rssKb) || !Number.isFinite(cpuPercent)) continue
-    rows.push({ pid, ppid, rssKb, cpuPercent })
-  }
-  return rows
-}
-
-export function collectTreePids(rows: readonly PsProcessRow[], rootPid: number): Set<number> {
-  const childrenByParent = new Map<number, number[]>()
-  for (const row of rows) {
-    const list = childrenByParent.get(row.ppid)
-    if (list) list.push(row.pid)
-    else childrenByParent.set(row.ppid, [row.pid])
-  }
-  const tree = new Set<number>([rootPid])
-  const queue: number[] = [rootPid]
-  while (queue.length > 0) {
-    const next = queue.shift()
-    if (next === undefined) break
-    const kids = childrenByParent.get(next)
-    if (!kids) continue
-    for (const kid of kids) {
-      if (tree.has(kid)) continue
-      tree.add(kid)
-      queue.push(kid)
-    }
-  }
-  return tree
-}
-
-export function sumTreeUsage(rows: readonly PsProcessRow[], tree: ReadonlySet<number>): ProcessTreeSample {
-  let totalKb = 0
-  let totalCpu = 0
-  for (const row of rows) {
-    if (!tree.has(row.pid)) continue
-    totalKb += row.rssKb
-    totalCpu += row.cpuPercent
-  }
-  return { rssBytes: totalKb * 1024, cpuPercent: totalCpu }
-}
-
-export async function sampleProcessTreeUsage(rootPid: number): Promise<ProcessTreeSample | null> {
-  let stdout: string
-  try {
-    const result = await execFileAsync("ps", ["-A", "-o", "pid=,ppid=,rss=,pcpu="], {
-      timeout: PS_TIMEOUT_MS,
-      maxBuffer: 4 * 1024 * 1024,
-    })
-    stdout = result.stdout
-  } catch {
-    return null
-  }
-  const rows = parsePsOutput(stdout)
-  if (!rows.some((r) => r.pid === rootPid)) return null
-  const tree = collectTreePids(rows, rootPid)
-  return sumTreeUsage(rows, tree)
-}

package/src/server/claude-pty/pty-process.adapter.ts

@@ -1,60 +0,0 @@
-export interface PtyProcess {
-  pid: number
-  sendInput(data: string): Promise<void>
-  resize(cols: number, rows: number): void
-  exited: Promise<number>
-  close(): void
-  kill(signal?: NodeJS.Signals | number): void
-}
-
-export interface SpawnPtyProcessArgs {
-  command: string
-  args: string[]
-  cwd: string
-  env: NodeJS.ProcessEnv
-  cols?: number
-  rows?: number
-  onOutput?: (chunk: string) => void
-}
-
-export async function spawnPtyProcess(opts: SpawnPtyProcessArgs): Promise<PtyProcess> {
-  if (typeof Bun.Terminal !== "function") {
-    throw new Error("Bun.Terminal not available — requires Bun 1.3.5+")
-  }
-
-  const cols = opts.cols ?? 120
-  const rows = opts.rows ?? 40
-
-  const terminal = new Bun.Terminal({
-    cols,
-    rows,
-    name: "xterm-256color",
-    data: (_t, data) => {
-      if (opts.onOutput) {
-        const chunk = Buffer.from(data).toString("utf8")
-        opts.onOutput(chunk)
-      }
-    },
-  })
-
-  const proc = Bun.spawn([opts.command, ...opts.args], {
-    cwd: opts.cwd,
-    env: opts.env,
-    terminal,
-  })
-
-  return {
-    pid: proc.pid,
-    async sendInput(data) { terminal.write(data) },
-    resize(newCols, newRows) { terminal.resize(newCols, newRows) },
-    exited: proc.exited,
-    close() {
-      try { terminal.close() } catch { }
-      try { proc.kill("SIGTERM") } catch { }
-    },
-    kill(signal) {
-      try { terminal.close() } catch { }
-      try { proc.kill(signal ?? "SIGKILL") } catch { }
-    },
-  }
-}

package/src/server/claude-pty/pty-process.test.ts

@@ -1,49 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import { spawnPtyProcess } from "./pty-process.adapter"
-
-describe("spawnPtyProcess", () => {
-  test(
-    "spawns a child process and exits cleanly",
-    async () => {
-      if (process.platform === "win32") {
-        console.log("skip: PTY not supported on Windows")
-        return
-      }
-      if (typeof Bun.Terminal !== "function") {
-        console.log("skip: Bun.Terminal not available")
-        return
-      }
-      const handle = await spawnPtyProcess({
-        command: "/bin/sh",
-        args: ["-c", "echo hello"],
-        cwd: "/tmp",
-        env: process.env,
-        cols: 80,
-        rows: 24,
-      })
-      const exitCode = await handle.exited
-      expect(exitCode).toBe(0)
-      handle.close()
-    },
-    30_000,
-  )
-
-  test(
-    "captures output via onOutput callback",
-    async () => {
-      if (process.platform === "win32" || typeof Bun.Terminal !== "function") return
-      const chunks: string[] = []
-      const handle = await spawnPtyProcess({
-        command: "/bin/sh",
-        args: ["-c", "echo hi"],
-        cwd: "/tmp",
-        env: process.env,
-        onOutput: (chunk) => chunks.push(chunk),
-      })
-      await handle.exited
-      handle.close()
-      expect(chunks.join("")).toContain("hi")
-    },
-    30_000,
-  )
-})

package/src/server/claude-pty/resolve-binary.adapter.ts

@@ -1,106 +0,0 @@
-import { stat } from "node:fs/promises"
-import path from "node:path"
-import { promisify } from "node:util"
-import { execFile } from "node:child_process"
-
-const execFileAsync = promisify(execFile)
-
-export interface ResolveClaudeBinaryArgs {
-  env: NodeJS.ProcessEnv
-  homeDir: string
-  cwd?: string
-  platform?: NodeJS.Platform
-  arch?: NodeJS.Architecture
-}
-
-export interface ResolveClaudeBinaryResult {
-  path: string
-  source: "env-CLAUDE_EXECUTABLE" | "env-CLAUDE_CODE_EXECPATH" | "PATH" | "node_modules"
-  triedPaths: string[]
-}
-
-function expandTilde(p: string, home: string): string {
-  return p.replace(/^~(?=\/|$)/, home)
-}
-
-async function isExecutableFile(p: string): Promise<boolean> {
-  try {
-    const s = await stat(p)
-    return s.isFile()
-  } catch {
-    return false
-  }
-}
-
-async function whichClaude(env: NodeJS.ProcessEnv, platform: NodeJS.Platform): Promise<string | null> {
-  const cmd = platform === "win32" ? "where" : "which"
-  try {
-    const { stdout } = await execFileAsync(cmd, ["claude"], { env, timeout: 2000 })
-    const first = stdout.split(/\r?\n/).map((line) => line.trim()).find((line) => line.length > 0)
-    if (!first) return null
-    if (!(await isExecutableFile(first))) return null
-    return first
-  } catch {
-    return null
-  }
-}
-
-function buildNodeModulesCandidates(cwd: string, platform: NodeJS.Platform, arch: NodeJS.Architecture): string[] {
-  const tag = `${platform}-${arch}`
-  const pkgDir = `@anthropic-ai/claude-agent-sdk-${tag}`
-  const candidates: string[] = []
-  let dir = path.resolve(cwd)
-  while (true) {
-    candidates.push(path.join(dir, "node_modules", pkgDir, "claude"))
-    const parent = path.dirname(dir)
-    if (parent === dir) break
-    dir = parent
-  }
-  return candidates
-}
-
-export async function resolveClaudeBinary(args: ResolveClaudeBinaryArgs): Promise<ResolveClaudeBinaryResult> {
-  const env = args.env
-  const home = args.homeDir
-  const cwd = args.cwd ?? process.cwd()
-  const platform = args.platform ?? process.platform
-  const arch = args.arch ?? process.arch
-  const tried: string[] = []
-
-  if (env.CLAUDE_EXECUTABLE) {
-    const candidate = expandTilde(env.CLAUDE_EXECUTABLE, home)
-    tried.push(`CLAUDE_EXECUTABLE=${candidate}`)
-    if (await isExecutableFile(candidate)) {
-      return { path: candidate, source: "env-CLAUDE_EXECUTABLE", triedPaths: tried }
-    }
-  }
-
-  if (env.CLAUDE_CODE_EXECPATH) {
-    const candidate = expandTilde(env.CLAUDE_CODE_EXECPATH, home)
-    tried.push(`CLAUDE_CODE_EXECPATH=${candidate}`)
-    if (await isExecutableFile(candidate)) {
-      return { path: candidate, source: "env-CLAUDE_CODE_EXECPATH", triedPaths: tried }
-    }
-  }
-
-  const fromPath = await whichClaude(env, platform)
-  tried.push(`PATH lookup: ${fromPath ?? "<not found>"}`)
-  if (fromPath) {
-    return { path: fromPath, source: "PATH", triedPaths: tried }
-  }
-
-  const candidates = buildNodeModulesCandidates(cwd, platform, arch)
-  for (const candidate of candidates) {
-    tried.push(candidate)
-    if (await isExecutableFile(candidate)) {
-      return { path: candidate, source: "node_modules", triedPaths: tried }
-    }
-  }
-
-  throw new Error(
-    `Unable to locate the \`claude\` CLI binary. Set CLAUDE_EXECUTABLE to an absolute path, `
-    + `install \`@anthropic-ai/claude-code\` globally so \`claude\` is on PATH, or install `
-    + `\`@anthropic-ai/claude-agent-sdk\` so the platform-bundled binary exists in node_modules. `
-    + `Tried:\n  - ${tried.join("\n  - ")}`,
-  )
-}

package/src/server/claude-pty/resolve-binary.test.ts

@@ -1,118 +0,0 @@
-import { afterEach, beforeEach, describe, expect, test } from "bun:test"
-import { chmod, mkdir, mkdtemp, rm, writeFile } from "node:fs/promises"
-import { tmpdir } from "node:os"
-import path from "node:path"
-import { resolveClaudeBinary } from "./resolve-binary.adapter"
-
-describe("resolveClaudeBinary", () => {
-  let workDir: string
-
-  beforeEach(async () => {
-    workDir = await mkdtemp(path.join(tmpdir(), "kanna-resolve-binary-"))
-  })
-
-  afterEach(async () => {
-    await rm(workDir, { recursive: true, force: true })
-  })
-
-  async function makeExec(p: string): Promise<void> {
-    await mkdir(path.dirname(p), { recursive: true })
-    await writeFile(p, "#!/bin/sh\necho fake\n", { encoding: "utf8" })
-    await chmod(p, 0o755)
-  }
-
-  test("returns CLAUDE_EXECUTABLE when set and exists", async () => {
-    const bin = path.join(workDir, "fake-claude")
-    await makeExec(bin)
-    const result = await resolveClaudeBinary({
-      env: { CLAUDE_EXECUTABLE: bin, PATH: "" },
-      homeDir: workDir,
-      cwd: workDir,
-      platform: "darwin",
-      arch: "arm64",
-    })
-    expect(result.source).toBe("env-CLAUDE_EXECUTABLE")
-    expect(result.path).toBe(bin)
-  })
-
-  test("expands tilde in CLAUDE_EXECUTABLE", async () => {
-    const bin = path.join(workDir, "tilde-claude")
-    await makeExec(bin)
-    const result = await resolveClaudeBinary({
-      env: { CLAUDE_EXECUTABLE: "~/tilde-claude", PATH: "" },
-      homeDir: workDir,
-      cwd: workDir,
-      platform: "darwin",
-      arch: "arm64",
-    })
-    expect(result.path).toBe(bin)
-  })
-
-  test("falls back to CLAUDE_CODE_EXECPATH when CLAUDE_EXECUTABLE missing file", async () => {
-    const bin = path.join(workDir, "execpath-claude")
-    await makeExec(bin)
-    const result = await resolveClaudeBinary({
-      env: {
-        CLAUDE_EXECUTABLE: path.join(workDir, "does-not-exist"),
-        CLAUDE_CODE_EXECPATH: bin,
-        PATH: "",
-      },
-      homeDir: workDir,
-      cwd: workDir,
-      platform: "darwin",
-      arch: "arm64",
-    })
-    expect(result.source).toBe("env-CLAUDE_CODE_EXECPATH")
-    expect(result.path).toBe(bin)
-  })
-
-  test("falls back to node_modules platform-bundled binary", async () => {
-    const inner = path.join(workDir, "nested", "deep")
-    await mkdir(inner, { recursive: true })
-    const bundled = path.join(workDir, "node_modules", "@anthropic-ai", "claude-agent-sdk-darwin-arm64", "claude")
-    await makeExec(bundled)
-    const result = await resolveClaudeBinary({
-      env: { PATH: "" },
-      homeDir: workDir,
-      cwd: inner,
-      platform: "darwin",
-      arch: "arm64",
-    })
-    expect(result.source).toBe("node_modules")
-    expect(result.path).toBe(bundled)
-  })
-
-  test("walks parent dirs when looking up node_modules bundled binary", async () => {
-    const inner = path.join(workDir, "a", "b", "c")
-    await mkdir(inner, { recursive: true })
-    const bundled = path.join(workDir, "node_modules", "@anthropic-ai", "claude-agent-sdk-linux-x64", "claude")
-    await makeExec(bundled)
-    const result = await resolveClaudeBinary({
-      env: { PATH: "" },
-      homeDir: workDir,
-      cwd: inner,
-      platform: "linux",
-      arch: "x64",
-    })
-    expect(result.path).toBe(bundled)
-  })
-
-  test("throws with all tried paths when nothing resolves", async () => {
-    let err: unknown
-    try {
-      await resolveClaudeBinary({
-        env: { CLAUDE_EXECUTABLE: path.join(workDir, "missing"), PATH: "" },
-        homeDir: workDir,
-        cwd: workDir,
-        platform: "darwin",
-        arch: "arm64",
-      })
-    } catch (caught) {
-      err = caught
-    }
-    expect(err).toBeInstanceOf(Error)
-    expect((err as Error).message).toContain("Unable to locate")
-    expect((err as Error).message).toContain("CLAUDE_EXECUTABLE")
-    expect((err as Error).message).toContain("node_modules/@anthropic-ai/claude-agent-sdk-darwin-arm64/claude")
-  }, 10_000)
-})

package/src/server/claude-pty/runtime-dir.adapter.ts

@@ -1,19 +0,0 @@
-import { mkdtemp, rm, writeFile } from "node:fs/promises"
-import path from "node:path"
-import { tmpdir } from "node:os"
-
-export async function createRuntimeDir(prefix: string): Promise<string> {
-  return await mkdtemp(path.join(tmpdir(), prefix))
-}
-
-export async function writeRuntimeFile(
-  filePath: string,
-  contents: string,
-  options?: { encoding?: BufferEncoding; mode?: number },
-): Promise<void> {
-  await writeFile(filePath, contents, options)
-}
-
-export async function removeRuntimeDir(dir: string): Promise<void> {
-  await rm(dir, { recursive: true, force: true })
-}

package/src/server/claude-pty/sandbox/detect.adapter.ts

@@ -1,17 +0,0 @@
-import { spawn } from "node:child_process"
-
-let cached: boolean | null = null
-
-export async function detectBwrap(): Promise<boolean> {
-  if (cached !== null) return cached
-  cached = await new Promise<boolean>((resolve) => {
-    const child = spawn("/usr/bin/which", ["bwrap"], { stdio: ["ignore", "ignore", "ignore"] })
-    child.on("close", (code) => resolve(code === 0))
-    child.on("error", () => resolve(false))
-  })
-  return cached
-}
-
-export function resetBwrapCacheForTest(): void {
-  cached = null
-}

package/src/server/claude-pty/sandbox/detect.test.ts

@@ -1,17 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import { detectBwrap, resetBwrapCacheForTest } from "./detect.adapter"
-
-describe("detectBwrap", () => {
-  test("returns boolean (real platform check)", async () => {
-    resetBwrapCacheForTest()
-    const result = await detectBwrap()
-    expect(typeof result).toBe("boolean")
-  })
-
-  test("subsequent calls hit cache (same result)", async () => {
-    resetBwrapCacheForTest()
-    const first = await detectBwrap()
-    const second = await detectBwrap()
-    expect(second).toBe(first)
-  })
-})

package/src/server/claude-pty/sandbox/platform.test.ts

@@ -1,35 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import { isSandboxSupported, isSandboxEnabledAsync } from "./platform"
-import { resetBwrapCacheForTest } from "./detect.adapter"
-
-describe("isSandboxSupported", () => {
-  test("true on darwin", () => {
-    expect(isSandboxSupported("darwin")).toBe(true)
-  })
-  test("false on linux (P4.1)", () => {
-    expect(isSandboxSupported("linux")).toBe(false)
-  })
-  test("false on win32", () => {
-    expect(isSandboxSupported("win32")).toBe(false)
-  })
-})
-
-describe("isSandboxEnabledAsync", () => {
-  test("respects env=off on linux", async () => {
-    expect(await isSandboxEnabledAsync({ platform: "linux", env: "off" })).toBe(false)
-  })
-
-  test("linux: depends on bwrap detection (sync no, async maybe yes)", async () => {
-    resetBwrapCacheForTest()
-    const r = await isSandboxEnabledAsync({ platform: "linux", env: undefined })
-    expect(typeof r).toBe("boolean")
-  })
-
-  test("darwin: always enabled when env not 'off'", async () => {
-    expect(await isSandboxEnabledAsync({ platform: "darwin", env: undefined })).toBe(true)
-  })
-
-  test("win32: always false", async () => {
-    expect(await isSandboxEnabledAsync({ platform: "win32", env: "on" })).toBe(false)
-  })
-})

package/src/server/claude-pty/sandbox/platform.ts

@@ -1,27 +0,0 @@
-import { detectBwrap } from "./detect.adapter"
-import { log } from "../../../shared/log"
-
-export function isSandboxSupported(platform: NodeJS.Platform): boolean {
-  return platform === "darwin"
-}
-
-export async function isSandboxEnabledAsync(args: {
-  platform: NodeJS.Platform
-  env: string | undefined
-}): Promise<boolean> {
-  if (args.env === "off") return false
-  if (args.platform === "darwin") return true
-  if (args.platform === "linux") {
-    const ok = await detectBwrap()
-    if (!ok) {
-      log.warn(
-        "[claude-pty/sandbox] bwrap not found on PATH — PTY OS sandbox is "
-        + "DISABLED (loses defense-in-depth against built-in credential "
-        + "reads). Install bubblewrap (apt/dnf/pacman install bubblewrap) "
-        + "or set KANNA_PTY_SANDBOX=off to silence this warning.",
-      )
-    }
-    return ok
-  }
-  return false
-}

package/src/server/claude-pty/sandbox/preflight-io.adapter.ts

@@ -1,14 +0,0 @@
-import { spawn } from "node:child_process"
-import { writeFile } from "node:fs/promises"
-
-export function spawnExitCode(command: string, args: string[]): Promise<number> {
-  return new Promise<number>((resolve) => {
-    const child = spawn(command, args, { stdio: ["ignore", "ignore", "ignore"] })
-    child.on("close", (code) => resolve(code ?? -1))
-    child.on("error", () => resolve(-1))
-  })
-}
-
-export function writeTextFile(p: string, contents: string): Promise<void> {
-  return writeFile(p, contents, "utf8")
-}