@vellumai/cli 0.10.6-dev.202607072040.fb971ce → 0.10.6-staging.1

package/src/lib/process.ts

@@ -1,12 +1,7 @@
 import { execFileSync } from "child_process";
 import { existsSync, readFileSync, unlinkSync } from "fs";
 
-import {
-  httpHealthCheck,
-  type HttpProbeEndpoint,
-  probeDaemonReadinessWithRetry,
-  waitForDaemonReady,
-} from "./http-client.js";
+import { httpHealthCheck, waitForDaemonReady } from "./http-client.js";
 
 /**
  * Verify that a PID belongs to a vellum-related process by inspecting its
@@ -83,43 +78,31 @@ export async function isProcessHealthy(
 
 /**
  * Outcome of {@link resolveProcessState}. Callers switch on `status`:
- * - `"healthy"` — process is alive and ready; `pid` is the live PID.
- * - `"unready"` — process is alive and healthy, but DB migrations were still
- *   running when the readiness wait elapsed.
- * - `"migration_failed"` — process is alive and healthy, but its DB migrations
- *   failed: a terminal state that never recovers without a restart. The
- *   process is kept alive (same keep-alive rule as `"unready"`).
+ * - `"healthy"` — process is alive and responding; `pid` is the live PID.
  * - `"needs_start"` — process was dead, hung (and killed), or a stale PID
  *   was cleaned up. Caller should start a fresh process.
  */
 export type ProcessState =
   | { status: "healthy"; pid: number }
-  | { status: "unready"; pid: number }
-  | { status: "migration_failed"; pid: number }
   | { status: "needs_start"; pid: number | null };
 
 /**
- * Determine whether a PID-tracked process is alive and healthy. If the process
- * exists but is unresponsive, waits up to `readinessWaitMs` (default 60s —
- * matches the spawner's own `waitForDaemonReady` timeout so a concurrent
- * caller never kills a process the spawner is still waiting on) for it to
- * start answering health checks. If it remains unresponsive, verifies it
- * belongs to Vellum before killing it, then cleans up the PID file.
+ * Determine whether a PID-tracked process is alive and healthy. If the
+ * process exists but is unresponsive, waits up to `readinessWaitMs`
+ * (default 60s — matches the spawner's own `waitForDaemonReady` timeout
+ * so a concurrent caller never kills a daemon the spawner is still
+ * waiting on) for it to finish initializing. If it remains unresponsive,
+ * verifies it belongs to Vellum before killing it, then cleans up the
+ * PID file.
  *
- * When callers pass the `"readyz"` readiness endpoint, this also CLASSIFIES
- * DB migration readiness with a single `/readyz` probe (read from the body —
- * the status code stays 200 during migrations for k8s). It never waits for
- * readiness: the kill/keep decision depends only on the health check, and
- * callers that want to wait out a migration own that wait themselves. A
- * health-checking process is kept alive when migrations are running or
- * failed.
+ * Encapsulates the full health → readiness-wait → guard → kill → cleanup
+ * flow so callers don't need to reimplement it.
  */
 export async function resolveProcessState(
   pidFile: string,
   healthPort: number,
   label: string,
   readinessWaitMs: number = 60_000,
-  readinessEndpoint: HttpProbeEndpoint = "healthz",
 ): Promise<ProcessState> {
   const result = await isProcessHealthy(pidFile, healthPort);
 
@@ -127,52 +110,29 @@ export async function resolveProcessState(
     return { status: "needs_start", pid: null };
   }
 
-  if (!result.healthy) {
-    // Alive but not healthy — may still be starting up.
-    const becameHealthy = await waitForDaemonReady(
-      healthPort,
-      readinessWaitMs,
-      "healthz",
-    );
-    if (!becameHealthy) {
-      // Genuinely hung — kill if it belongs to Vellum, otherwise just clean up.
-      if (isVellumProcess(result.pid)) {
-        console.log(
-          `${label} process alive (pid ${result.pid}) but not responding — killing and restarting...`,
-        );
-        await stopProcess(result.pid, label);
-      } else {
-        console.log(
-          `Stale PID file (pid ${result.pid} is not a Vellum process) — cleaning up...`,
-        );
-      }
-      removeFiles(pidFile);
-      return { status: "needs_start", pid: result.pid };
-    }
+  if (result.healthy) {
+    return { status: "healthy", pid: result.pid };
   }
 
-  if (readinessEndpoint !== "healthz") {
-    const readiness = await probeDaemonReadinessWithRetry(healthPort);
-    if (readiness === "failed") {
-      return { status: "migration_failed", pid: result.pid };
-    }
-    if (readiness === "unreachable") {
-      // The daemon answered the health check moments ago but not /readyz —
-      // it may have died in between (e.g. OOM during a heavy migration).
-      // Re-verify liveness before reporting it alive, so callers don't skip
-      // starting a replacement for a dead process.
-      if (!isProcessAlive(pidFile).alive) {
-        removeFiles(pidFile);
-        return { status: "needs_start", pid: result.pid };
-      }
-      return { status: "unready", pid: result.pid };
-    }
-    if (readiness !== "ready") {
-      return { status: "unready", pid: result.pid };
-    }
+  // Alive but not healthy — may still be starting up.
+  const becameHealthy = await waitForDaemonReady(healthPort, readinessWaitMs);
+  if (becameHealthy) {
+    return { status: "healthy", pid: result.pid };
   }
 
-  return { status: "healthy", pid: result.pid };
+  // Genuinely hung — kill if it belongs to Vellum, otherwise just clean up.
+  if (isVellumProcess(result.pid)) {
+    console.log(
+      `${label} process alive (pid ${result.pid}) but not responding — killing and restarting...`,
+    );
+    await stopProcess(result.pid, label);
+  } else {
+    console.log(
+      `Stale PID file (pid ${result.pid} is not a Vellum process) — cleaning up...`,
+    );
+  }
+  removeFiles(pidFile);
+  return { status: "needs_start", pid: result.pid };
 }
 
 /**

package/src/lib/upgrade-lifecycle.ts

@@ -20,7 +20,6 @@ import {
 import { getStateDir } from "./environments/paths.js";
 import { getCurrentEnvironment } from "./environments/resolve.js";
 import { loadGuardianToken } from "./guardian-token.js";
-import { classifyReadyzResponse } from "./http-client.js";
 import { fetchReleases, resolveImageRefs } from "./platform-releases.js";
 import {
   getBuilderManagedEnvKeys,
@@ -365,16 +364,8 @@ export async function fetchPreviousVersion(
 }
 
 /**
- * Poll the gateway `/readyz` endpoint until the assistant reports migrations
- * ready or the timeout elapses. Returns whether the assistant became ready.
- *
- * Readiness is classified from the response BODY, not the status code: the
- * assistant's `/readyz` (forwarded through the gateway proxy) returns 200
- * with `ready: false` while DB migrations run — the k8s keep-the-pod contract
- * — so `resp.ok` alone would declare an upgrade successful before its
- * migrations settle and make the caller's rollback path unreachable. A
- * terminally failed migration returns immediately so rollback/restore can run
- * without burning the timeout.
+ * Poll the gateway `/readyz` endpoint until it returns 200 or the timeout
+ * elapses. Returns whether the assistant became ready.
  */
 export async function waitForReady(runtimeUrl: string): Promise<boolean> {
   const readyUrl = `${runtimeUrl}/readyz`;
@@ -385,25 +376,21 @@ export async function waitForReady(runtimeUrl: string): Promise<boolean> {
       const resp = await loopbackSafeFetch(readyUrl, {
         signal: AbortSignal.timeout(5000),
       });
-      const body = (await resp.json().catch(() => null)) as {
-        status?: string;
-        upstream?: number;
-      } | null;
-      const readiness = classifyReadyzResponse(resp.ok, body);
-      if (readiness === "ready") {
+      if (resp.ok) {
         const elapsedSec = ((Date.now() - start) / 1000).toFixed(1);
         console.log(`Assistant ready after ${elapsedSec}s`);
         return true;
       }
-      if (readiness === "failed") {
-        console.log(
-          "Assistant database migrations FAILED — treating the assistant as not ready so recovery can run.",
-        );
-        return false;
+      let detail = "";
+      try {
+        const body = await resp.text();
+        const json = JSON.parse(body);
+        const parts = [json.status];
+        if (json.upstream != null) parts.push(`upstream=${json.upstream}`);
+        detail = ` — ${parts.join(", ")}`;
+      } catch {
+        // ignore parse errors
       }
-      const parts = [body?.status].filter(Boolean);
-      if (body?.upstream != null) parts.push(`upstream=${body.upstream}`);
-      const detail = parts.length > 0 ? ` — ${parts.join(", ")}` : "";
       console.log(`Readiness check: ${resp.status}${detail} (retrying...)`);
     } catch {
       // Connection refused / timeout — not up yet
@@ -504,40 +491,17 @@ export async function rollbackMigrations(
       body.targetWorkspaceMigrationId = targetWorkspaceMigrationId;
     if (rollbackToRegistryCeiling) body.rollbackToRegistryCeiling = true;
 
-    // The CLI can learn of a migration failure (via the forwarded /readyz
-    // body) up to a couple of seconds before the gateway's own assistant
-    // health poll opens its traffic gate — a POST landing in that window
-    // gets 503 {status:"starting"}. Retry through it rather than silently
-    // skipping the rollback.
-    const startingGateDeadline = Date.now() + 15_000;
-    let resp: Response;
-    for (;;) {
-      resp = await loopbackSafeFetch(
-        `${gatewayUrl}/v1/admin/rollback-migrations`,
-        {
-          method: "POST",
-          headers,
-          body: JSON.stringify(body),
-          signal: AbortSignal.timeout(120_000),
-        },
-      );
-      if (resp.ok) break;
+    const resp = await loopbackSafeFetch(
+      `${gatewayUrl}/v1/admin/rollback-migrations`,
+      {
+        method: "POST",
+        headers,
+        body: JSON.stringify(body),
+        signal: AbortSignal.timeout(120_000),
+      },
+    );
+    if (!resp.ok) {
       const text = await resp.text();
-      let gatewayStarting = false;
-      try {
-        // The daemon's running-migrations 503 also says "starting" but
-        // carries a `reason` field — don't retry against that one (the
-        // rollback stays blocked until migrations leave the running state).
-        const parsed = JSON.parse(text) as { status?: string; reason?: string };
-        gatewayStarting =
-          parsed.status === "starting" && parsed.reason === undefined;
-      } catch {
-        // Non-JSON error body — not the starting gate.
-      }
-      if (gatewayStarting && Date.now() < startingGateDeadline) {
-        await new Promise((r) => setTimeout(r, 1_000));
-        continue;
-      }
       console.warn(`⚠️  Migration rollback failed (${resp.status}): ${text}`);
       return false;
     }
@@ -559,43 +523,6 @@ export async function rollbackMigrations(
   }
 }
 
-/**
- * Recovery step for a reverted stack that reports terminally failed
- * migrations: import the backup (the failed-state migrations/import
- * exemption admits it, and the import replaces the DB wholesale), then
- * restart the containers — the failed readiness latch only clears on
- * restart — and re-check readiness. Shared by the upgrade failure branch
- * and performDockerRollback's auto-rollback.
- */
-export async function attemptFailedStateRestore(opts: {
-  runtimeUrl: string;
-  assistantId: string;
-  backupPath: string;
-  /** Label for log lines, e.g. "pre-upgrade" or "pre-rollback". */
-  backupLabel: string;
-  res: Parameters<typeof stopContainers>[0];
-  containerOptions: Parameters<typeof startContainers>[0];
-}): Promise<{ restored: boolean; ready: boolean }> {
-  console.log(
-    `📦 Reverted stack not ready — attempting ${opts.backupLabel} backup restore...`,
-  );
-  console.log(`   Source: ${opts.backupPath}`);
-  const restored = await restoreBackup(
-    opts.runtimeUrl,
-    opts.assistantId,
-    opts.backupPath,
-  );
-  if (!restored) {
-    return { restored: false, ready: false };
-  }
-  console.log(
-    "   Backup imported — restarting containers to complete recovery...",
-  );
-  await stopContainers(opts.res);
-  await startContainers(opts.containerOptions, (msg) => console.log(msg));
-  return { restored: true, ready: await waitForReady(opts.runtimeUrl) };
-}
-
 // ---------------------------------------------------------------------------
 // Shared Docker rollback orchestration
 // ---------------------------------------------------------------------------
@@ -760,8 +687,7 @@ export async function performDockerRollback(
   }
 
   // Recover the assistant host port from the entry, fall back to default.
-  const assistantPort =
-    entry.containerInfo?.assistantPort ?? ASSISTANT_INTERNAL_PORT;
+  const assistantPort = entry.containerInfo?.assistantPort ?? ASSISTANT_INTERNAL_PORT;
 
   // Broadcast SSE "starting" event
   console.log("📢 Notifying connected clients...");
@@ -955,40 +881,10 @@ export async function performDockerRollback(
           (msg) => console.log(msg),
         );
 
-        let revertReady = await waitForReady(entry.runtimeUrl);
-        let restoredViaFailedState = false;
-        if (!revertReady && preRollbackBackupPath) {
-          const recovery = await attemptFailedStateRestore({
-            runtimeUrl: entry.runtimeUrl,
-            assistantId: entry.assistantId,
-            backupPath: preRollbackBackupPath,
-            backupLabel: "pre-rollback",
-            res,
-            containerOptions: {
-              signingKey,
-              bootstrapSecret,
-              cesServiceToken,
-              extraAssistantEnv,
-              extraGatewayEnv,
-              gatewayPort,
-              assistantPort,
-              imageTags: currentImageRefs,
-              instanceName,
-              res,
-            },
-          });
-          restoredViaFailedState = recovery.restored;
-          if (recovery.restored) {
-            revertReady = recovery.ready;
-          }
-        }
+        const revertReady = await waitForReady(entry.runtimeUrl);
         if (revertReady) {
           // Restore from pre-rollback backup on failure
-          if (restoredViaFailedState) {
-            console.log(
-              "   ✅ Data restored during failed-state recovery above\n",
-            );
-          } else if (preRollbackBackupPath) {
+          if (preRollbackBackupPath) {
             await broadcastUpgradeEvent(
               entry.runtimeUrl,
               entry.assistantId,

package/tsconfig.json

@@ -10,7 +10,7 @@
     "resolveJsonModule": true,
     "noEmit": true,
     "jsx": "react-jsx",
-    "types": ["bun"]
+    "types": ["bun-types"]
   },
   "include": ["src/**/*", "src/**/*.tsx"],
   "exclude": ["node_modules"]

package/node_modules/@vellumai/local-mode/node_modules/@vellumai/environments/package.json

@@ -1,18 +0,0 @@
-{
-  "name": "@vellumai/environments",
-  "version": "0.0.1",
-  "private": true,
-  "license": "MIT",
-  "type": "module",
-  "exports": {
-    ".": "./src/index.ts"
-  },
-  "scripts": {
-    "typecheck": "bunx tsc --noEmit",
-    "test": "bun test src/"
-  },
-  "devDependencies": {
-    "@types/bun": "1.3.11",
-    "typescript": "5.9.3"
-  }
-}

package/node_modules/@vellumai/local-mode/node_modules/@vellumai/environments/src/__tests__/package-boundary.test.ts

@@ -1,95 +0,0 @@
-/**
- * Package boundary tests for @vellumai/environments.
- *
- * This package is the lowest layer of the shared-packages hierarchy: pure
- * environment types and constants with no runtime dependencies. It must
- * stay a leaf so any consumer (CLI, assistant, local-mode host) can depend
- * on it without dragging in a dependency tree.
- *
- * Enforces that the package:
- * 1. Imports only node builtins and its own relative modules — no `@vellumai/*`
- *    packages and no third-party runtime imports.
- * 2. Declares no runtime `dependencies` (devDependencies only).
- * 3. Is marked `private`.
- */
-
-import { describe, expect, test } from "bun:test";
-import { readFileSync, readdirSync, statSync } from "node:fs";
-import { join, resolve } from "node:path";
-
-const PACKAGE_ROOT = resolve(import.meta.dirname, "../..");
-const SRC_DIR = join(PACKAGE_ROOT, "src");
-
-function collectSourceFiles(dir: string): string[] {
-  const files: string[] = [];
-  for (const entry of readdirSync(dir)) {
-    const full = join(dir, entry);
-    const stat = statSync(full);
-    if (stat.isDirectory()) {
-      if (entry === "node_modules" || entry === "__tests__") continue;
-      files.push(...collectSourceFiles(full));
-    } else if (
-      entry.endsWith(".ts") &&
-      !entry.endsWith(".test.ts") &&
-      !entry.endsWith(".d.ts")
-    ) {
-      files.push(full);
-    }
-  }
-  return files;
-}
-
-/**
- * Matches the module specifier of any `import ... from "<spec>"` /
- * `export ... from "<spec>"` / `require("<spec>")` statement.
- */
-const IMPORT_SPEC = /(?:from|require\s*\(\s*)["']([^"']+)["']/g;
-
-/** A bare specifier is anything that is not a relative or node-builtin import. */
-function isForbiddenSpecifier(spec: string): boolean {
-  if (spec.startsWith(".") || spec.startsWith("/")) return false;
-  if (spec.startsWith("node:")) return false;
-  return true;
-}
-
-describe("package boundary", () => {
-  const sourceFiles = collectSourceFiles(SRC_DIR);
-
-  test("has source files to validate", () => {
-    expect(sourceFiles.length).toBeGreaterThan(0);
-  });
-
-  test("imports only node builtins and relative modules", () => {
-    const violations: string[] = [];
-
-    for (const file of sourceFiles) {
-      const lines = readFileSync(file, "utf-8").split("\n");
-      for (let i = 0; i < lines.length; i++) {
-        for (const match of lines[i]!.matchAll(IMPORT_SPEC)) {
-          const spec = match[1]!;
-          if (isForbiddenSpecifier(spec)) {
-            const relative = file.replace(PACKAGE_ROOT + "/", "");
-            violations.push(`${relative}:${i + 1}: ${spec}`);
-          }
-        }
-      }
-    }
-
-    if (violations.length > 0) {
-      throw new Error(
-        `Found ${violations.length} forbidden import(s) in @vellumai/environments:\n` +
-          violations.map((v) => `  - ${v}`).join("\n") +
-          "\n\n@vellumai/environments is a pure types/constants leaf and must\n" +
-          "import only node builtins and its own relative modules.",
-      );
-    }
-  });
-
-  test("package.json declares it as private with no runtime dependencies", () => {
-    const pkg = JSON.parse(
-      readFileSync(join(PACKAGE_ROOT, "package.json"), "utf-8"),
-    );
-    expect(pkg.private).toBe(true);
-    expect(pkg.dependencies ?? {}).toEqual({});
-  });
-});

package/node_modules/@vellumai/local-mode/node_modules/@vellumai/environments/src/index.ts

@@ -1,11 +0,0 @@
-/**
- * @vellumai/environments — the single source of truth for Vellum's known
- * deployment environments (names, platform/web URLs, per-service port
- * blocks). Consumed by the CLI, the assistant daemon, and the local-mode
- * host library so the environment list is defined exactly once on the TS
- * side. The Swift client mirrors the same set in `VellumEnvironment.swift`.
- *
- * Intentionally free of runtime dependencies: pure types and constants only.
- */
-export * from "./types.js";
-export * from "./seeds.js";

package/node_modules/@vellumai/local-mode/node_modules/@vellumai/environments/src/seeds.ts

@@ -1,70 +0,0 @@
-import type { EnvironmentDefinition, PortMap } from "./types.js";
-
-/**
- * Non-prod port blocks. Each environment gets a 1000-port window in the
- * 17000–21000 band. Within a block, services are spaced 100 apart so up to
- * 100 assistants can coexist without the scan (`findAvailablePort`) running
- * one service's range into the next. Band chosen to sit below Linux's
- * default ephemeral start (32768) and macOS's (49152), and away from the
- * 3000/5000/8000/9000 dev-tool swamp. Production keeps its legacy,
- * non-contiguous port set (7821/7830/6333/8090/8080/8765): cross-env
- * collision is the only problem this change targets, prod is unaffected
- * because only one env's assistants compete on a given machine, and
- * churning it would leave existing hatches on 7821 while new ones
- * allocated elsewhere.
- */
-function portBlock(base: number): PortMap {
-  return {
-    daemon: base,
-    gateway: base + 100,
-    qdrant: base + 200,
-    ces: base + 300,
-    outboundProxy: base + 400,
-    tcp: base + 500,
-  };
-}
-
-/**
- * Built-in environment definitions and the source of truth for the
- * set of known environment names.
- *
- * Custom environments via a user config file are a future phase — see the
- * "Coexisting environments" design doc. Until then, a call site that needs a
- * new environment must add it here and rebuild.
- */
-export const SEEDS: Record<string, EnvironmentDefinition> = {
-  production: {
-    name: "production",
-    platformUrl: "https://platform.vellum.ai",
-    webUrl: "https://www.vellum.ai",
-  },
-  staging: {
-    name: "staging",
-    platformUrl: "https://staging-platform.vellum.ai",
-    webUrl: "https://staging-assistant.vellum.ai",
-    portsOverride: portBlock(17000),
-  },
-  test: {
-    name: "test",
-    // Non-functional URL — used only by unit tests for URL resolution, never
-    // hit in production.
-    platformUrl: "https://test-platform.vellum.ai",
-    webUrl: "https://dev-assistant.vellum.ai",
-    portsOverride: portBlock(19000),
-  },
-  dev: {
-    name: "dev",
-    platformUrl: "https://dev-platform.vellum.ai",
-    webUrl: "https://dev-assistant.vellum.ai",
-    portsOverride: portBlock(18000),
-  },
-  local: {
-    name: "local",
-    platformUrl: "http://localhost:8000",
-    webUrl: "http://localhost:3000",
-    // assistantPlatformUrl: "http://host.docker.internal:8000",
-    // ^ uncomment this once dockerized hatch path is live.
-    // The assistant runs in a different network namespace than the host.
-    portsOverride: portBlock(20000),
-  },
-};

package/node_modules/@vellumai/local-mode/node_modules/@vellumai/environments/src/types.ts

@@ -1,70 +0,0 @@
-/**
- * Environment type definitions. Environments are deployment targets with
- * their own platform backend and their own isolated on-host state. See the
- * "Coexisting environments" design doc for the full model.
- */
-
-/**
- * Per-service default port set. Phase 5 (per-environment port offsets) is
- * deferred from MVP, so today every environment uses the same port set. The
- * shape exists so the rest of the stack can call `getDefaultPorts(env)` and
- * gain per-env offsets later without changing any call sites.
- */
-export interface PortMap {
-  daemon: number;
-  gateway: number;
-  qdrant: number;
-  ces: number;
-  outboundProxy: number;
-  tcp: number;
-}
-
-/**
- * A resolved environment definition. Required fields are `name` and
- * `platformUrl`. All other fields are optional and declared upfront — new
- * fields are additive, never breaking. `name` is intentionally typed as
- * `string` (not `keyof SEEDS`) so custom environments can be represented by
- * future layers (user config file, ad-hoc env vars, etc.).
- */
-export interface EnvironmentDefinition {
-  name: string;
-  platformUrl: string;
-
-  /**
-   * The web app (Next.js) base URL for browser-facing pages like
-   * `/account/login`. In production this is separate from the API backend
-   * (e.g. `www.vellum.ai` vs `platform.vellum.ai`); locally it's
-   * `localhost:3000` vs `localhost:8000`.
-   *
-   * Mirrors `VellumEnvironment.webURL` on the Swift side.
-   */
-  webUrl: string;
-
-  /**
-   * Override for the platform URL the assistant process itself uses. Only
-   * differs from `platformUrl` when the assistant runs in a different network
-   * namespace than the host (e.g. Docker on macOS, where the host's localhost
-   * is reached via `host.docker.internal`). Falls back to `platformUrl` when
-   * unset.
-   */
-  assistantPlatformUrl?: string;
-
-  /** Human-readable label for UI surfaces. */
-  displayName?: string;
-
-  /** Hint for UI surfaces that want to tint or badge their display. */
-  tintColor?: string;
-
-  /** Per-service port overrides merged on top of defaults. */
-  portsOverride?: Partial<PortMap>;
-
-  /** Override for the XDG config directory. */
-  configDirOverride?: string;
-
-  /**
-   * Override for the directory containing the lockfile. Populated by the
-   * resolver from `VELLUM_LOCKFILE_DIR` (an existing e2e test escape hatch)
-   * so path helpers don't read env vars directly.
-   */
-  lockfileDirOverride?: string;
-}

package/node_modules/@vellumai/local-mode/node_modules/@vellumai/environments/tsconfig.json

@@ -1,20 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2022",
-    "module": "NodeNext",
-    "moduleResolution": "NodeNext",
-    "strict": true,
-    "esModuleInterop": true,
-    "skipLibCheck": true,
-    "forceConsistentCasingInFileNames": true,
-    "resolveJsonModule": true,
-    "declaration": true,
-    "declarationMap": true,
-    "sourceMap": true,
-    "outDir": "./dist",
-    "rootDir": "./src",
-    "types": ["bun"]
-  },
-  "include": ["src/**/*"],
-  "exclude": ["node_modules", "dist"]
-}