kcg-code 0.0.0-stage → 0.2.0

package/src/cli/__tests__/dashboard.test.ts

@@ -0,0 +1,224 @@
+import { describe, expect, test } from "bun:test";
+import {
+  activeProvider,
+  bestUrl,
+  type DashboardInfo,
+  menuItems,
+  portInputError,
+  renderDashboard,
+  renderSnapshot,
+  takeSnapshot,
+} from "../dashboard";
+
+function makeInfo(overrides: Partial<DashboardInfo> = {}): DashboardInfo {
+  return {
+    server: {
+      store: {
+        listProjects: () => [{ id: "p1" }],
+        listSessions: () => [
+          { id: "s1", status: "running", title: "active job" },
+          { id: "s2", status: "idle", title: null },
+        ],
+      },
+      tunnel: { status: () => ({ phase: "signed_out", account: null, error: null }) },
+    } as unknown as DashboardInfo["server"],
+    port: 3000,
+    hostname: "127.0.0.1",
+    ...overrides,
+  };
+}
+
+describe("renderDashboard", () => {
+  test("logo KCG + status simpel Running", () => {
+    const frame = renderDashboard(makeInfo(), "0.1.0");
+    expect(frame).toContain("kcgcode");
+    expect(frame).toContain("v0.1.0");
+    expect(frame).toContain("██╗");
+    expect(frame).toContain("Running");
+    expect(frame).toContain("Local");
+    expect(frame).toContain("PID");
+    expect(frame).toContain("up 0s");
+    expect(frame).toContain("Tunnel");
+    expect(frame).toContain("Open in browser");
+    expect(frame).toContain("↑↓ move");
+    expect(frame).not.toContain("CONFIG");
+  });
+
+  test("baris Awake menampilkan status keep-awake", () => {
+    const on = renderDashboard(
+      makeInfo({
+        keepAwake: { status: () => ({ active: true, method: "systemd-inhibit", error: null }) },
+      }),
+      "0.1.0",
+    );
+    expect(on).toContain("Awake");
+    expect(on).toContain("sleep blocked");
+
+    const off = renderDashboard(
+      makeInfo({
+        keepAwake: {
+          status: () => ({ active: false, method: null, error: "disabled (--allow-sleep)" }),
+        },
+      }),
+      "0.1.0",
+    );
+    expect(off).toContain("off · disabled");
+    expect(renderDashboard(makeInfo(), "0.1.0")).not.toContain("Awake");
+  });
+
+  test("stats berubah saat data store berubah (refresh in-place)", () => {
+    let sessions: { id: string; status: string; title: string | null }[] = [];
+    const info = makeInfo({
+      server: {
+        store: {
+          listProjects: () => [],
+          listSessions: () => sessions,
+        },
+        tunnel: {
+          status: () => ({
+            phase: "online",
+            account: { url: "https://demo.example.com" },
+            error: null,
+          }),
+        },
+      } as unknown as DashboardInfo["server"],
+    });
+
+    const before = renderDashboard(info, "0.1.0");
+    expect(before).toContain("Sessions");
+
+    sessions = [{ id: "s9", status: "running", title: "fresh" }];
+    const after = renderDashboard(info, "0.1.0");
+    expect(after).toContain("1 running");
+    expect(after).toContain("Tunnel");
+    expect(after).toContain("https://demo.example.com");
+    expect(after).not.toBe(before);
+  });
+
+  test("menu simpel + info provider kcg/lhr", () => {
+    const info = makeInfo({
+      server: {
+        store: {
+          listProjects: () => [],
+          listSessions: () => [],
+          getTunnelSettings: () => ({ provider: "lhr" }),
+        },
+        tunnel: {
+          status: () => ({ phase: "stopped", account: null, error: null, pairing: null }),
+        },
+        lhr: {
+          status: () => ({ phase: "online", url: "https://abc.lhr.life", error: null }),
+        },
+        tunnelProvider: () => "lhr" as const,
+      } as unknown as DashboardInfo["server"],
+    });
+
+    expect(activeProvider(info)).toBe("lhr");
+    expect(bestUrl(info)).toEqual({ label: "public (lhr)", url: "https://abc.lhr.life" });
+    expect(menuItems({}).map((m) => m.id)).toEqual([
+      "open",
+      "copy",
+      "qr",
+      "detail",
+      "port",
+      "background",
+      "quit",
+    ]);
+
+    const frame = renderDashboard(info, "0.1.0", { showQr: true, showDetail: true, menuIndex: 2 });
+    expect(frame).toContain("Running");
+    expect(frame).toContain("TUNNEL DETAIL");
+    expect(frame).toContain("OPEN ON PHONE");
+    expect(frame).toContain("lhr");
+    expect(frame).toContain("https://abc.lhr.life");
+    expect(frame).toContain("Hide phone QR");
+  });
+
+  test("URL publik punya baris sendiri", () => {
+    const info = makeInfo({
+      server: {
+        store: { listProjects: () => [], listSessions: () => [] },
+        tunnel: {
+          status: () => ({
+            phase: "online",
+            account: { url: "https://me.example.com" },
+            error: null,
+          }),
+        },
+      } as unknown as DashboardInfo["server"],
+    });
+    const frame = renderDashboard(info, "0.1.0");
+    expect(frame).toMatch(/Public\s+https:\/\/me\.example\.com/);
+    expect(frame).toContain("kcg · online");
+  });
+
+  test("konfirmasi quit saat ada session running", () => {
+    const frame = renderDashboard(makeInfo(), "0.1.0", { confirm: "quit" });
+    expect(frame).toContain("press q again");
+    expect(renderDashboard(makeInfo(), "0.1.0")).not.toContain("press q again");
+  });
+
+  test("form ganti port + catatan port fallback", () => {
+    const info = makeInfo({ portNote: "3000 in use", port: 3001 });
+    const frame = renderDashboard(info, "0.1.0", {
+      portInput: "40",
+      portError: "Enter a port number",
+    });
+    expect(frame).toContain("CHANGE PORT");
+    expect(frame).toContain("current 3001");
+    expect(frame).toContain("› 40");
+    expect(frame).toContain("Enter a port number");
+    expect(frame).toContain("(3000 in use)");
+    expect(frame).toContain("esc cancel");
+    expect(renderDashboard(makeInfo(), "0.1.0")).not.toContain("CHANGE PORT");
+  });
+
+  test("status Restarting saat ganti port", () => {
+    expect(renderDashboard(makeInfo({ restarting: true }), "0.1.0")).toContain("Restarting");
+  });
+});
+
+describe("portInputError", () => {
+  test("validasi input port", () => {
+    expect(portInputError("")).not.toBeNull();
+    expect(portInputError("0")).not.toBeNull();
+    expect(portInputError("70000")).not.toBeNull();
+    expect(portInputError("80")).toContain("1024");
+    expect(portInputError("4000")).toBeNull();
+  });
+});
+
+describe("mode background (dashboard untuk daemon)", () => {
+  test("menu Stop / Run in foreground / Close dashboard", () => {
+    expect(menuItems({}, "background").map((m) => m.id)).toEqual([
+      "open",
+      "copy",
+      "qr",
+      "detail",
+      "port",
+      "foreground",
+      "stop",
+      "quit",
+    ]);
+  });
+
+  test("render snapshot daemon", () => {
+    const snap = { ...takeSnapshot(makeInfo()), mode: "background" as const, pid: 4242 };
+    const frame = renderSnapshot(snap, "0.1.0");
+    expect(frame).toContain("Running in background");
+    expect(frame).toContain("PID 4242");
+    expect(frame).toContain("Stop server");
+    expect(frame).toContain("Close dashboard");
+    expect(frame).toContain("server keeps running");
+    expect(frame).toContain("q close");
+    expect(frame).not.toContain("Run in background");
+
+    const busy = renderSnapshot({ ...snap, restarting: true, busyLabel: "Stopping…" }, "0.1.0");
+    expect(busy).toContain("Stopping…");
+  });
+
+  test("snapshot bisa diserialisasi ke daemon.json", () => {
+    const snap = takeSnapshot(makeInfo(), "background");
+    expect(JSON.parse(JSON.stringify(snap))).toEqual(snap);
+  });
+});

package/src/cli/__tests__/keep-awake.test.ts

@@ -0,0 +1,44 @@
+import { describe, expect, test } from "bun:test";
+import { parseArgs } from "../args";
+import { disabledKeepAwake, inhibitCommand, startKeepAwake } from "../keep-awake";
+
+describe("inhibitCommand", () => {
+  test("linux: systemd-inhibit memblok sleep & idle, child cat terikat stdin", () => {
+    const cmd = inhibitCommand("linux", 123);
+    expect(cmd?.[0]).toBe("systemd-inhibit");
+    expect(cmd).toContain("--what=sleep:idle");
+    expect(cmd).toContain("--mode=block");
+    expect(cmd?.at(-1)).toBe("cat");
+  });
+
+  test("darwin: caffeinate menunggu pid kcgcode", () => {
+    expect(inhibitCommand("darwin", 123)).toEqual(["caffeinate", "-i", "-s", "-w", "123"]);
+  });
+
+  test("platform lain tidak didukung", () => {
+    expect(inhibitCommand("freebsd", 123)).toBeNull();
+  });
+});
+
+describe("startKeepAwake", () => {
+  test("platform tak didukung → nonaktif dengan alasan", async () => {
+    const ka = await startKeepAwake("aix");
+    expect(ka.status()).toEqual({ active: false, method: null, error: "unsupported on aix" });
+    ka.stop();
+  });
+
+  test("disabledKeepAwake melaporkan --allow-sleep", () => {
+    expect(disabledKeepAwake().status().active).toBe(false);
+    expect(disabledKeepAwake().status().error).toContain("--allow-sleep");
+  });
+});
+
+describe("parseArgs --allow-sleep", () => {
+  test("default keep awake", () => {
+    expect(parseArgs([]).allowSleep).toBeUndefined();
+  });
+
+  test("flag mengizinkan sleep", () => {
+    expect(parseArgs(["start", "--allow-sleep"]).allowSleep).toBe(true);
+  });
+});

package/src/cli/__tests__/port.test.ts

@@ -0,0 +1,86 @@
+import { afterEach, describe, expect, test } from "bun:test";
+import { mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import { resolveConfig, saveConfigPort } from "../../config";
+import { choosePort, portIsFree, requestedPort } from "../port";
+
+describe("requestedPort", () => {
+  test("prioritas flag > env > config > default", () => {
+    expect(requestedPort({ flag: 1, env: "2", config: 3 })).toEqual({ port: 1, source: "flag" });
+    expect(requestedPort({ env: "2", config: 3 })).toEqual({ port: 2, source: "env" });
+    expect(requestedPort({ env: "abc", config: 3 })).toEqual({ port: 3, source: "config" });
+    expect(requestedPort({})).toEqual({ port: 3000, source: "default" });
+  });
+});
+
+describe("choosePort", () => {
+  const busy = (taken: number[]) => (_h: string, p: number) => !taken.includes(p);
+
+  test("port kosong dipakai apa adanya", async () => {
+    expect(await choosePort("127.0.0.1", { port: 3000, source: "default" }, busy([]))).toEqual({
+      ok: true,
+      port: 3000,
+      fallbackFrom: null,
+    });
+  });
+
+  test("default/config terpakai → pindah ke port kosong berikutnya", async () => {
+    expect(
+      await choosePort("127.0.0.1", { port: 3000, source: "default" }, busy([3000, 3001])),
+    ).toEqual({
+      ok: true,
+      port: 3002,
+      fallbackFrom: 3000,
+    });
+    expect(
+      await choosePort("127.0.0.1", { port: 4000, source: "config" }, busy([4000])),
+    ).toMatchObject({
+      ok: true,
+      port: 4001,
+    });
+  });
+
+  test("port eksplisit terpakai → error, tanpa fallback", async () => {
+    const res = await choosePort("127.0.0.1", { port: 3000, source: "flag" }, busy([3000]));
+    expect(res.ok).toBe(false);
+    if (!res.ok) expect(res.error).toContain("--port");
+  });
+
+  test("portIsFree mendeteksi port yang sedang dipakai", async () => {
+    const s = Bun.serve({ hostname: "127.0.0.1", port: 0, fetch: () => new Response() });
+    try {
+      expect(await portIsFree("127.0.0.1", s.port as number)).toBe(false);
+    } finally {
+      s.stop(true);
+    }
+  });
+});
+
+describe("config port", () => {
+  let dir = "";
+  afterEach(() => rmSync(dir, { recursive: true, force: true }));
+
+  test("saveConfigPort menyimpan port & mempertahankan key lain", () => {
+    dir = mkdtempSync(path.join(tmpdir(), "kcg-port-"));
+    const file = path.join(dir, "config.json");
+    writeFileSync(file, JSON.stringify({ sandboxRoot: dir, extra: true }));
+
+    expect(saveConfigPort(file, 4321).ok).toBe(true);
+    expect(JSON.parse(readFileSync(file, "utf8"))).toEqual({
+      sandboxRoot: dir,
+      extra: true,
+      port: 4321,
+    });
+
+    const cfg = resolveConfig(file);
+    expect(cfg.ok && cfg.data.port).toBe(4321);
+  });
+
+  test("port tidak valid di config ditolak", () => {
+    dir = mkdtempSync(path.join(tmpdir(), "kcg-port-"));
+    const file = path.join(dir, "config.json");
+    writeFileSync(file, JSON.stringify({ sandboxRoot: dir, port: "abc" }));
+    expect(resolveConfig(file).ok).toBe(false);
+  });
+});

package/src/cli/args.ts

@@ -0,0 +1,186 @@
+/**
+ * Parser argumen CLI kcgcode (tanpa dependency eksternal).
+ */
+
+import { c } from "./theme";
+
+export interface CliArgs {
+  command:
+    | "start"
+    | "stop"
+    | "status"
+    | "logs"
+    | "init"
+    | "reset-lock"
+    | "help"
+    | "version"
+    | "invalid";
+  port?: number;
+  host?: string;
+  /** Path berkas konfigurasi (override KCG_CONFIG_PATH). */
+  config?: string;
+  open: boolean;
+  /** Izinkan OS sleep (matikan keep-awake). */
+  allowSleep?: boolean;
+  /** Jalankan di background (lepas dari terminal). */
+  detach?: boolean;
+  /** `logs`: ikuti log baru. */
+  follow?: boolean;
+  /** `logs`: jumlah baris terakhir. */
+  lines?: number;
+  /** Argumen tak dikenal / pesan error. */
+  error?: string;
+}
+
+const HELP_TEXT = `kcgcode — control CLI AI agents from your phone
+
+USAGE
+  kcgcode [start] [options]
+  kcgcode start -d [options]
+  kcgcode stop | status | logs [-f]
+  kcgcode init [options]
+  kcgcode help | --help | -h
+  kcgcode version | --version | -v
+
+COMMANDS
+  start (default)   Run server + terminal dashboard; if it already runs
+                    in background, open its dashboard instead
+  stop              Stop the background server
+  status            Show background server status
+  logs              Show background server log (-f to follow)
+  init              Create kcg-code.config.json & local sandbox folder
+  reset-lock        Remove the app lock (forgot PIN/password) & sign out all devices
+
+OPTIONS
+  -p, --port <n>    HTTP port (default: config "port" or 3000; a busy
+                    default is swapped for the next free port)
+  -H, --host <h>    Bind host (default 127.0.0.1 / env KCG_HOST)
+  -c, --config <f>  Config path (default ~/.kcgcode/config.json)
+  -d, --detach      Run in background (keeps running after terminal closes)
+  --open            Open the web dashboard in a browser after start
+  -f, --follow      logs: keep printing new lines
+  -n, --lines <n>   logs: number of lines to show (default 50)
+  --allow-sleep     Let the OS sleep while running (default: keep awake)
+  -h, --help        Show help
+  -v, --version     Show version
+
+ENV
+  KCG_PORT              HTTP port
+  KCG_HOST              Bind host
+  KCG_CONFIG_PATH       Config file path
+  KCG_DB_PATH           SQLite path (default ~/.kcgcode/data/kcg-code.sqlite)
+  KCG_ALLOW_SLEEP=1     Same as --allow-sleep
+
+EXAMPLES
+  kcgcode
+  kcgcode init
+  kcgcode start --port 4000 --open
+  kcgcode start -d && kcgcode logs -f
+  kcgcode init --config ~/.kcgcode/config.json
+`;
+
+/** Help berwarna: heading cyan, flag/command hijau, deskripsi redup. */
+export function helpText(): string {
+  return HELP_TEXT.split("\n")
+    .map((line, i) => {
+      if (i === 0) return c.cyanBright(line);
+      if (/^[A-Z]+$/.test(line)) return c.cyanBright(line);
+      const m = line.match(/^(\s{2})(\S.*?)(\s{2,})(\S.*)$/);
+      if (m) return `${m[1]}${c.green(m[2] as string)}${m[3]}${c.dim(m[4] as string)}`;
+      if (/^\s+kcgcode/.test(line)) return c.white(line);
+      return line;
+    })
+    .join("\n");
+}
+
+export function parseArgs(argv: string[]): CliArgs {
+  const args: CliArgs = { command: "start", open: false };
+  const rest = [...argv];
+
+  // Command eksplisit di posisi pertama (bukan flag)
+  const first = rest[0];
+  if (first === "init") {
+    args.command = "init";
+    rest.shift();
+  } else if (first === "reset-lock") {
+    args.command = "reset-lock";
+    rest.shift();
+  } else if (first === "start" || first === "stop" || first === "status" || first === "logs") {
+    args.command = first;
+    rest.shift();
+  } else if (first === "help") {
+    args.command = "help";
+    rest.shift();
+  } else if (first === "version") {
+    args.command = "version";
+    rest.shift();
+  }
+
+  for (let i = 0; i < rest.length; i++) {
+    const a = rest[i];
+    if (a === undefined) continue;
+
+    if (a === "-h" || a === "--help") {
+      return { command: "help", open: false };
+    }
+    if (a === "-v" || a === "--version") {
+      return { command: "version", open: false };
+    }
+    if (a === "--open") {
+      args.open = true;
+      continue;
+    }
+    if (a === "-d" || a === "--detach") {
+      args.detach = true;
+      continue;
+    }
+    if (a === "-f" || a === "--follow") {
+      args.follow = true;
+      continue;
+    }
+    if (a === "-n" || a === "--lines") {
+      const raw = rest[++i];
+      const n = Number(raw);
+      if (raw === undefined || !Number.isInteger(n) || n <= 0) {
+        return { ...args, command: "invalid", error: `Invalid value for ${a}` };
+      }
+      args.lines = n;
+      continue;
+    }
+    if (a === "--allow-sleep") {
+      args.allowSleep = true;
+      continue;
+    }
+    if (a === "-p" || a === "--port") {
+      const raw = rest[++i];
+      if (raw === undefined)
+        return { ...args, command: "invalid", error: `Missing value for ${a}` };
+      const n = Number(raw);
+      if (!Number.isInteger(n) || n <= 0 || n > 65535) {
+        return { ...args, command: "invalid", error: `Invalid port "${raw}"` };
+      }
+      args.port = n;
+      continue;
+    }
+    if (a === "-H" || a === "--host") {
+      const raw = rest[++i];
+      if (raw === undefined)
+        return { ...args, command: "invalid", error: `Missing value for ${a}` };
+      args.host = raw;
+      continue;
+    }
+    if (a === "-c" || a === "--config") {
+      const raw = rest[++i];
+      if (raw === undefined)
+        return { ...args, command: "invalid", error: `Missing value for ${a}` };
+      args.config = raw;
+      continue;
+    }
+    if (a.startsWith("-")) {
+      return { ...args, command: "invalid", error: `Unknown option "${a}"` };
+    }
+    return { ...args, command: "invalid", error: `Unknown command "${a}"` };
+  }
+
+  return args;
+}

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;
+    });
+  });
+}