kcg-code 0.1.0 → 0.2.0

package/src/cli/attach.ts

@@ -0,0 +1,154 @@
+/**
+ * Dashboard untuk server yang sudah jalan di background (daemon).
+ *
+ * Data dibaca dari `daemon.json` yang ditulis daemon tiap beberapa detik;
+ * kontrol lewat sinyal (stop) atau spawn ulang daemon (ganti port).
+ * Menutup dashboard (q) tidak menghentikan server.
+ */
+import { saveConfigPort } from "../config";
+import type { CliArgs } from "./args";
+import { type DaemonState, isAlive, readDaemonState, startDetached, stopDaemon } from "./daemon";
+import { type DashboardSnapshot, openBrowser, startDashboard } from "./dashboard";
+import { portIsFree } from "./port";
+import { c, symbols } from "./theme";
+
+const POLL_MS = 1000;
+
+/** Snapshot minimal untuk state daemon versi lama (tanpa `snapshot`). */
+export function snapshotFromState(state: DaemonState): DashboardSnapshot {
+  const target = state.publicUrl
+    ? { label: "public", url: state.publicUrl }
+    : { label: "local", url: state.localUrl };
+  return {
+    mode: "background",
+    port: state.port,
+    pid: state.pid,
+    memory: "—",
+    startedAt: state.startedAt,
+    localUrl: state.localUrl,
+    networkUrl: null,
+    target,
+    publicUrl: state.publicUrl,
+    tunnel: { text: state.publicUrl ? "online" : "—", color: state.publicUrl ? "green" : "gray" },
+    pairingUri: null,
+    tunnelDetail: {
+      provider: null,
+      kcg: { phase: "—", url: null },
+      lhr: null,
+    },
+    keepAwake: null,
+    sessions: 0,
+    running: 0,
+    projects: 0,
+    portNote: null,
+    restarting: false,
+  };
+}
+
+function hints(): string {
+  return `${c.cyan("kcgcode")} ${c.dim("to reopen ·")} ${c.cyan("kcgcode stop")} ${c.dim("to stop")}`;
+}
+
+/**
+ * Tampilkan dashboard untuk daemon yang berjalan. Hanya resolve bila user
+ * memilih "Run in foreground" — daemon sudah dihentikan, dan nilai yang
+ * dikembalikan adalah port yang dipakai daemon (untuk diteruskan pemanggil).
+ */
+export async function attachToDaemon(
+  args: CliArgs,
+  configPath: string,
+  initial: DaemonState,
+): Promise<number> {
+  let current = initial;
+  let busyLabel: string | null = null;
+
+  const source = (): DashboardSnapshot => {
+    const base = current.snapshot ?? snapshotFromState(current);
+    return { ...base, mode: "background", restarting: busyLabel !== null, busyLabel };
+  };
+
+  return new Promise<number>((resolve) => {
+    let dash: { stop(): void } | null = null;
+    let poller: ReturnType<typeof setInterval> | null = null;
+
+    const leave = (lines: string[], code = 0): never => {
+      if (poller) clearInterval(poller);
+      dash?.stop();
+      for (const line of lines) console.log(line);
+      process.exit(code);
+    };
+
+    // Ikuti state terbaru; bila daemon mati di luar kendali dashboard, keluar.
+    poller = setInterval(async () => {
+      if (busyLabel) return;
+      const state = await readDaemonState();
+      if (state && state.pid === current.pid && isAlive(state.pid)) {
+        current = state;
+      } else if (!isAlive(current.pid)) {
+        leave([`${c.yellow(symbols.warn)} kcgcode background server has stopped.`]);
+      }
+    }, POLL_MS);
+
+    const respawn = (port: number) => startDetached({ ...args, port, detach: true });
+
+    void startDashboard(source, {
+      onQuit: () =>
+        leave([
+          `${c.greenBright(symbols.check)} Dashboard closed — kcgcode keeps running in background.`,
+          `  ${hints()}`,
+        ]),
+      onOpenUrl: () => openBrowser(source().localUrl),
+      onStop: async () => {
+        busyLabel = "Stopping…";
+        const result = await stopDaemon(current);
+        leave([
+          result === "killed"
+            ? `${c.yellow(symbols.warn)} kcgcode force-killed (did not exit within 10s).`
+            : `${c.greenBright(symbols.check)} kcgcode stopped.`,
+        ]);
+      },
+      onForeground: async () => {
+        busyLabel = "Moving to this terminal…";
+        await stopDaemon(current);
+        if (poller) clearInterval(poller);
+        dash?.stop();
+        resolve(current.port);
+      },
+      onChangePort: async (next) => {
+        if (next !== current.port && !(await portIsFree(current.hostname, next))) {
+          return `Port ${next} is already in use`;
+        }
+        const saved = saveConfigPort(configPath, next);
+        if (!saved.ok) return saved.error;
+        if (next === current.port) return null;
+
+        const prev = current.port;
+        busyLabel = "Restarting…";
+        try {
+          await stopDaemon(current);
+          try {
+            current = await respawn(next);
+            return null;
+          } catch (err) {
+            // Gagal di port baru → hidupkan lagi di port lama.
+            current = await respawn(prev);
+            return `Cannot start on port ${next}: ${(err as Error).message}`;
+          }
+        } catch (err) {
+          leave(
+            [
+              `${c.redBright(symbols.cross)} ${(err as Error).message}`,
+              `  ${c.dim("Server is stopped. Run")} ${c.cyan("kcgcode")} ${c.dim("to start again.")}`,
+            ],
+            1,
+          );
+          return null;
+        } finally {
+          busyLabel = null;
+        }
+      },
+    }).then((d) => {
+      dash = d;
+    });
+  });
+}

package/src/cli/commands.ts

@@ -3,7 +3,7 @@
  */
 import { existsSync, mkdirSync, writeFileSync } from "node:fs";
 import path from "node:path";
-import { resolveConfig } from "../config";
+import { resolveConfig, saveConfigPort } from "../config";
 import { openSessionStore } from "../db";
 import spa from "../index.html";
 import {
@@ -19,9 +19,25 @@ import { createKcgServer } from "../server/app";
 import { resolveHostname } from "../server/host";
 import { createAuthService } from "../server/services/auth";
 import type { CliArgs } from "./args";
-import { openBrowser, startDashboard } from "./dashboard";
+import { attachToDaemon } from "./attach";
+import {
+  clearDaemonState,
+  daemonLogPath,
+  isDaemonChild,
+  printAlreadyRunning,
+  printStarted,
+  runningDaemon,
+  startDetached,
+  writeDaemonState,
+} from "./daemon";
+import { type DashboardInfo, openBrowser, startDashboard, takeSnapshot } from "./dashboard";
+import { disabledKeepAwake, startKeepAwake } from "./keep-awake";
+import { choosePort, portIsFree, requestedPort } from "./port";
 import { c, panel, row, symbols } from "./theme";
 
+/** Interval daemon menulis state + snapshot dashboard. */
+const DAEMON_STATE_MS = 2000;
+
 const SPA_PATHS = ["/", "/projects", "/projects/*", "/skills", "/settings", "/settings/*"];
 
 function applyEnvOverrides(args: CliArgs): void {
@@ -43,33 +59,93 @@ export async function runStart(args: CliArgs): Promise<void> {
   if (process.env.NODE_ENV === undefined) {
     process.env.NODE_ENV = "production";
   }
+  // Baca KCG_PORT sebelum di-override `--port`, untuk membedakan asal port.
+  const envPort = process.env.KCG_PORT;
   applyEnvOverrides(args);
 
   const cfg = resolveConfig();
   if (!cfg.ok) failConfig(cfg.error);
+  const config = cfg.data;
+
+  const daemonChild = isDaemonChild();
+  // Port daemon yang dipindah ke terminal ini ("Run in foreground").
+  let takeoverPort: number | undefined;
+  if (!daemonChild) {
+    const existing = await runningDaemon();
+    if (existing) {
+      if (args.detach || !process.stdout.isTTY) {
+        printAlreadyRunning(existing);
+        process.exit(1);
+      }
+      // Sudah jalan di background → buka dashboard untuk daemon tersebut.
+      takeoverPort = await attachToDaemon(args, config.configPath, existing);
+    }
+  }
 
-  const port = args.port ?? Number(process.env.KCG_PORT ?? 3000);
   const hostname = args.host ?? resolveHostname();
+  const choice = await choosePort(
+    hostname,
+    takeoverPort !== undefined
+      ? { port: takeoverPort, source: "config" }
+      : requestedPort({ flag: args.port, env: envPort, config: config.port }),
+  );
+  if (!choice.ok) {
+    console.error(`${c.redBright(symbols.cross)} ${choice.error}`);
+    console.error(`  ${c.dim("Pick another with")} ${c.cyan("--port <n>")}`);
+    process.exit(1);
+  }
+  const portNote = choice.fallbackFrom ? `${choice.fallbackFrom} in use` : null;
+
+  if (args.detach && !daemonChild) {
+    if (portNote) console.log(`${c.yellow(symbols.warn)} Port ${portNote} — using ${choice.port}.`);
+    try {
+      // Port final dikirim eksplisit agar anak tidak memilih ulang.
+      const state = await startDetached({ ...args, port: choice.port });
+      printStarted(state);
+      if (args.open) await openBrowser(state.localUrl);
+    } catch (err) {
+      console.error(`${c.redBright(symbols.cross)} ${(err as Error).message}`);
+      process.exit(1);
+    }
+    return;
+  }
 
-  const app = createKcgServer({
-    config: cfg.data,
-    spa,
-    spaPaths: SPA_PATHS,
-    port,
+  const boot = (port: number) =>
+    createKcgServer({
+      config,
+      spa,
+      spaPaths: SPA_PATHS,
+      port,
+      hostname,
+      uploadsRoot: resolveEffectiveUploadsDir(),
+    });
+  const localUrl = (port: number) =>
+    `http://${hostname === "0.0.0.0" || hostname === "::" ? "localhost" : hostname}:${port}`;
+
+  let app = boot(choice.port);
+  const info: DashboardInfo = {
+    server: app,
+    port: app.server.port ?? choice.port,
     hostname,
-    uploadsRoot: resolveEffectiveUploadsDir(),
-  });
+    portNote,
+    startedAt: Date.now(),
+  };
 
-  const resolvedPort = app.server.port ?? port;
-  const primaryUrl = `http://${hostname === "0.0.0.0" || hostname === "::" ? "localhost" : hostname}:${resolvedPort}`;
+  const allowSleep = args.allowSleep || process.env.KCG_ALLOW_SLEEP === "1";
+  const keepAwake = allowSleep ? disabledKeepAwake() : await startKeepAwake();
+  info.keepAwake = keepAwake;
 
   let shuttingDown = false;
   let dash: { stop(): void } | null = null;
+  let stateTimer: ReturnType<typeof setInterval> | null = null;
 
   async function shutdown(reason: string): Promise<void> {
     if (shuttingDown) return;
     shuttingDown = true;
     dash?.stop();
+    if (stateTimer) clearInterval(stateTimer);
+    if (daemonChild) clearDaemonState(process.pid);
+    keepAwake.stop();
     console.log(`\n${c.dim(`(${reason})`)} ${c.yellow("Saving session state and stopping…")}`);
     try {
       await app.close();
@@ -80,16 +156,93 @@ export async function runStart(args: CliArgs): Promise<void> {
     process.exit(0);
   }
 
-  dash = await startDashboard({
-    server: app,
-    port: resolvedPort,
-    hostname,
-    onQuit: (reason) => void shutdown(reason),
-    onOpenUrl: () => openBrowser(primaryUrl),
-  });
+  /** Simpan port ke config lalu restart server di port tersebut. Null = sukses. */
+  async function changePort(next: number): Promise<string | null> {
+    if (next !== info.port && !(await portIsFree(hostname, next))) {
+      return `Port ${next} is already in use`;
+    }
+    const saved = saveConfigPort(config.configPath, next);
+    if (!saved.ok) return saved.error;
+    if (next === info.port) {
+      info.portNote = null;
+      return null;
+    }
+
+    info.restarting = true;
+    const prev = info.port;
+    try {
+      await app.close();
+      try {
+        app = boot(next);
+      } catch (err) {
+        // Gagal bind di port baru → kembali ke port lama agar server tetap hidup.
+        app = boot(prev);
+        info.server = app;
+        return `Cannot start on port ${next}: ${(err as Error).message}`;
+      }
+      info.server = app;
+      info.port = app.server.port ?? next;
+      info.portNote = null;
+      return null;
+    } finally {
+      info.restarting = false;
+    }
+  }
+
+  /** Pindahkan server ke daemon: tutup server foreground, spawn ulang di background. */
+  async function moveToBackground(): Promise<void> {
+    if (shuttingDown) return;
+    shuttingDown = true;
+    dash?.stop();
+    keepAwake.stop();
+    console.log(c.yellow("Moving kcgcode to background…"));
+    try {
+      await app.close();
+      const state = await startDetached({ ...args, port: info.port, detach: true });
+      printStarted(state);
+      process.exit(0);
+    } catch (err) {
+      console.error(`${c.redBright(symbols.cross)} ${(err as Error).message}`);
+      console.error(
+        `  ${c.dim("Server is stopped. Run")} ${c.cyan("kcgcode")} ${c.dim("to start again.")}`,
+      );
+      process.exit(1);
+    }
+  }
 
-  if (args.open) {
-    void openBrowser(primaryUrl);
+  if (daemonChild) {
+    // Tanpa dashboard: tulis state + snapshot dashboard berkala untuk
+    // `status`/`stop` dan dashboard yang memantau daemon (`kcgcode`).
+    const writeState = () => {
+      const snapshot = takeSnapshot(info, "background");
+      return writeDaemonState({
+        pid: process.pid,
+        port: info.port,
+        hostname,
+        localUrl: localUrl(info.port),
+        publicUrl: snapshot.publicUrl,
+        startedAt: snapshot.startedAt,
+        logFile: daemonLogPath(),
+        snapshot,
+      });
+    };
+    await writeState();
+    stateTimer = setInterval(() => void writeState(), DAEMON_STATE_MS);
+    // Terminal asal ditutup tidak boleh menghentikan server.
+    process.on("SIGHUP", () => {});
+    console.log(`kcgcode running in background · pid ${process.pid} · ${localUrl(info.port)}`);
+  } else {
+    // `info` dimutasi saat restart port; dashboard membacanya ulang tiap render.
+    dash = await startDashboard(() => takeSnapshot(info), {
+      onQuit: (reason) => void shutdown(reason),
+      onOpenUrl: () => openBrowser(localUrl(info.port)),
+      onChangePort: changePort,
+      onBackground: () => void moveToBackground(),
+    });
+
+    if (args.open) {
+      void openBrowser(localUrl(info.port));
+    }
   }
 
   process.on("SIGINT", () => void shutdown("SIGINT"));

package/src/cli/daemon.ts

@@ -0,0 +1,275 @@
+/**
+ * Mode background (daemon) untuk kcgcode.
+ *
+ * `kcgcode start -d` men-spawn proses anak yang lepas dari terminal
+ * (session baru via `detached`, stdio ke file log), lalu parent keluar.
+ * Menutup terminal tidak membunuh server.
+ *
+ * State daemon disimpan di `<data>/daemon.json` (samping SQLite, ikut mode
+ * runtime) — dipakai `status`, `stop`, `logs`, dan cek single-instance.
+ */
+import { spawn } from "node:child_process";
+import {
+  closeSync,
+  existsSync,
+  mkdirSync,
+  openSync,
+  readFileSync,
+  renameSync,
+  rmSync,
+  statSync,
+  writeFileSync,
+} from "node:fs";
+import path from "node:path";
+import { resolveEffectiveDbPath } from "../paths";
+import type { CliArgs } from "./args";
+import { type DashboardSnapshot, formatUptime } from "./dashboard";
+import { c, panel, row, symbols } from "./theme";
+
+/** Penanda env untuk proses anak daemon. */
+export const DAEMON_CHILD_ENV = "KCG_DAEMON_CHILD";
+
+const READY_TIMEOUT_MS = 15_000;
+const STOP_TIMEOUT_MS = 10_000;
+const POLL_MS = 150;
+/** Log dirotasi ke `.1` saat start bila melewati ukuran ini. */
+const MAX_LOG_BYTES = 5 * 1024 * 1024;
+
+export interface DaemonState {
+  pid: number;
+  port: number;
+  hostname: string;
+  localUrl: string;
+  /** URL publik tunnel terakhir yang diketahui (diperbarui berkala). */
+  publicUrl: string | null;
+  startedAt: number;
+  logFile: string;
+  /** Data dashboard terbaru — dibaca dashboard yang memantau daemon. */
+  snapshot?: DashboardSnapshot;
+}
+
+export function isDaemonChild(): boolean {
+  return process.env[DAEMON_CHILD_ENV] === "1";
+}
+
+function runDir(): string {
+  return path.dirname(resolveEffectiveDbPath());
+}
+
+export function daemonStatePath(): string {
+  return path.join(runDir(), "daemon.json");
+}
+
+export function daemonLogPath(): string {
+  return path.join(runDir(), "kcgcode.log");
+}
+
+/** true bila proses dengan pid ini masih hidup. */
+export function isAlive(pid: number): boolean {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (err) {
+    // EPERM = proses ada tapi milik user lain.
+    return (err as NodeJS.ErrnoException).code === "EPERM";
+  }
+}
+
+export async function readDaemonState(): Promise<DaemonState | null> {
+  const file = Bun.file(daemonStatePath());
+  if (!(await file.exists())) return null;
+  try {
+    return (await file.json()) as DaemonState;
+  } catch {
+    return null;
+  }
+}
+
+/** State daemon yang prosesnya masih hidup; state basi dibersihkan. */
+export async function runningDaemon(): Promise<DaemonState | null> {
+  const state = await readDaemonState();
+  if (!state) return null;
+  if (isAlive(state.pid)) return state;
+  clearDaemonState();
+  return null;
+}
+
+export async function writeDaemonState(state: DaemonState): Promise<void> {
+  await Bun.write(daemonStatePath(), `${JSON.stringify(state, null, 2)}\n`);
+}
+
+/** Hapus state — hanya bila milik pid ini (default: proses sekarang). */
+export function clearDaemonState(ownerPid?: number): void {
+  const p = daemonStatePath();
+  if (!existsSync(p)) return;
+  if (ownerPid !== undefined) {
+    try {
+      const state = JSON.parse(readFileSync(p, "utf8")) as DaemonState;
+      if (state.pid !== ownerPid) return;
+    } catch {
+      // state rusak — hapus saja
+    }
+  }
+  rmSync(p, { force: true });
+}
+
+/** Argumen yang diteruskan ke proses anak (tanpa -d / --open). */
+export function childArgv(args: CliArgs): string[] {
+  const out = ["start"];
+  if (args.port !== undefined) out.push("--port", String(args.port));
+  if (args.host !== undefined) out.push("--host", args.host);
+  if (args.config !== undefined) out.push("--config", path.resolve(args.config));
+  if (args.allowSleep) out.push("--allow-sleep");
+  return out;
+}
+
+function rotateLog(logFile: string): void {
+  try {
+    if (statSync(logFile).size > MAX_LOG_BYTES) renameSync(logFile, `${logFile}.1`);
+  } catch {
+    // belum ada log
+  }
+}
+
+async function tailLines(file: string, n: number): Promise<string[]> {
+  const f = Bun.file(file);
+  if (!(await f.exists())) return [];
+  const size = f.size;
+  const text = await f.slice(Math.max(0, size - 64 * 1024), size).text();
+  return text
+    .split("\n")
+    .filter((l) => l.trim() !== "")
+    .slice(-n);
+}
+
+/** Spawn server di background lalu tunggu sampai siap. */
+export async function startDetached(args: CliArgs): Promise<DaemonState> {
+  const logFile = daemonLogPath();
+  mkdirSync(runDir(), { recursive: true });
+  rotateLog(logFile);
+  const fd = openSync(logFile, "a");
+  writeFileSync(fd, `\n=== kcgcode start ${new Date().toISOString()} ===\n`);
+
+  const script = process.argv[1] as string;
+  const child = spawn(process.execPath, [script, ...childArgv(args)], {
+    detached: true,
+    stdio: ["ignore", fd, fd],
+    env: { ...process.env, [DAEMON_CHILD_ENV]: "1" },
+    cwd: process.cwd(),
+    windowsHide: true,
+  });
+  child.unref();
+  closeSync(fd);
+
+  const pid = child.pid;
+  if (!pid) throw new Error("failed to spawn background process");
+
+  const deadline = Date.now() + READY_TIMEOUT_MS;
+  while (Date.now() < deadline) {
+    await Bun.sleep(POLL_MS);
+    const state = await readDaemonState();
+    if (state?.pid === pid) return state;
+    if (!isAlive(pid)) {
+      const tail = await tailLines(logFile, 8);
+      throw new Error(
+        `background process exited during startup${tail.length ? `:\n${tail.join("\n")}` : ""}`,
+      );
+    }
+  }
+  throw new Error(`server not ready after ${READY_TIMEOUT_MS / 1000}s — check ${logFile}`);
+}
+
+function statePanel(state: DaemonState, title: string): string {
+  return panel(title, [
+    row("Status", c.greenBright(`${symbols.bullet} running in background`)),
+    row("Local", c.cyan(state.localUrl)),
+    ...(state.publicUrl ? [row("Public", c.cyanBright(state.publicUrl))] : []),
+    row("PID", c.white(String(state.pid))),
+    row("Uptime", c.white(formatUptime(Date.now() - state.startedAt))),
+    row("Log", c.dim(state.logFile)),
+    "",
+    c.dim(`${c.cyan("kcgcode status")} · ${c.cyan("kcgcode logs -f")} · ${c.cyan("kcgcode stop")}`),
+  ]);
+}
+
+export function printStarted(state: DaemonState): void {
+  console.log(statePanel(state, "KCGCODE"));
+  console.log(c.dim("You can close this terminal — the server keeps running."));
+}
+
+/** Pesan saat instance lain sudah jalan di background. */
+export function printAlreadyRunning(state: DaemonState): void {
+  console.error(
+    `${c.yellowBright(symbols.warn)} kcgcode is already running in background ${c.dim(`(pid ${state.pid})`)}`,
+  );
+  console.error(`  ${c.dim("Open")} ${c.cyan(state.publicUrl ?? state.localUrl)}`);
+  console.error(`  ${c.dim("Stop it first with")} ${c.cyan("kcgcode stop")}`);
+}
+
+export async function runStatus(): Promise<void> {
+  const state = await runningDaemon();
+  if (!state) {
+    console.log(`${c.dim(symbols.idle)} kcgcode is ${c.yellow("not running")} in background.`);
+    console.log(`  ${c.dim("Start it with")} ${c.cyan("kcgcode start -d")}`);
+    process.exitCode = 1;
+    return;
+  }
+  console.log(statePanel(state, "KCGCODE"));
+}
+
+/** Kirim SIGTERM lalu tunggu; SIGKILL bila tidak keluar dalam batas waktu. */
+export async function stopDaemon(state: DaemonState): Promise<"stopped" | "killed"> {
+  try {
+    process.kill(state.pid, "SIGTERM");
+  } catch {
+    // sudah mati
+  }
+  const deadline = Date.now() + STOP_TIMEOUT_MS;
+  while (Date.now() < deadline && isAlive(state.pid)) await Bun.sleep(POLL_MS);
+
+  let result: "stopped" | "killed" = "stopped";
+  if (isAlive(state.pid)) {
+    process.kill(state.pid, "SIGKILL");
+    result = "killed";
+  }
+  clearDaemonState(state.pid);
+  return result;
+}
+
+export async function runStop(): Promise<void> {
+  const state = await runningDaemon();
+  if (!state) {
+    console.log(`${c.dim(symbols.idle)} kcgcode is not running in background.`);
+    return;
+  }
+  process.stdout.write(`${c.yellow("Stopping")} kcgcode ${c.dim(`(pid ${state.pid})`)}…`);
+  const result = await stopDaemon(state);
+  console.log(
+    result === "killed"
+      ? ` ${c.yellow("force-killed")} ${c.dim("(did not exit within 10s)")}`
+      : ` ${c.greenBright(symbols.check)} stopped.`,
+  );
+}
+
+export async function runLogs(args: CliArgs): Promise<void> {
+  const logFile = daemonLogPath();
+  if (!existsSync(logFile)) {
+    console.log(`${c.dim("No log yet at")} ${c.cyan(logFile)}`);
+    return;
+  }
+  for (const line of await tailLines(logFile, args.lines ?? 50)) console.log(line);
+  if (!args.follow) return;
+
+  // Follow: baca byte baru secara berkala (rotasi → mulai dari awal).
+  let offset = Bun.file(logFile).size;
+  for (;;) {
+    await Bun.sleep(500);
+    const f = Bun.file(logFile);
+    const size = f.size;
+    if (size < offset) offset = 0;
+    if (size > offset) {
+      process.stdout.write(await f.slice(offset, size).text());
+      offset = size;
+    }
+  }
+}