@mycadet/cli 0.0.1 → 0.12.6-dev.202610072225.d7acd73

package/src/lib/upgrade-preflight.ts

@@ -0,0 +1,130 @@
+import type { ReleaseListItem } from "./platform-releases.js";
+import { compareVersions, versionsEqual } from "./version-compat.js";
+
+export interface UpgradeTargetResolution {
+  kind: "ok" | "version-not-found" | "no-releases";
+  /** Resolved target version (kind "ok" only). */
+  target: string | null;
+  /** compareVersions(target, current); null when either side is unknown/unparseable. */
+  comparison: number | null;
+  isNoOp: boolean;
+  isDowngrade: boolean;
+}
+
+/**
+ * Resolve the upgrade target version from the releases list and compare it
+ * against the running version. Pure — callers fetch releases/current first.
+ *
+ * - An explicit version is validated against the releases list when one is
+ *   available (`releases !== null`); absent from the list → "version-not-found".
+ * - No explicit version → latest release, skipping non-stable heads
+ *   (mirrors the web UI: `releases.find(r => r.is_stable !== false) ?? releases[0]`).
+ * - `releases === null` (platform unreachable) with an explicit version
+ *   trusts the explicit version; without one → "no-releases".
+ */
+export function resolveUpgradeTarget(args: {
+  explicitVersion: string | null;
+  releases: ReleaseListItem[] | null;
+  currentVersion: string | undefined;
+}): UpgradeTargetResolution {
+  const { explicitVersion, releases, currentVersion } = args;
+
+  let target: string | null = null;
+  if (explicitVersion) {
+    if (releases !== null) {
+      const found = releases.find((r) =>
+        versionsEqual(r.version ?? "", explicitVersion),
+      );
+      if (!found) {
+        return {
+          kind: "version-not-found",
+          target: null,
+          comparison: null,
+          isNoOp: false,
+          isDowngrade: false,
+        };
+      }
+    }
+    target = explicitVersion;
+  } else {
+    if (releases === null || releases.length === 0) {
+      return {
+        kind: "no-releases",
+        target: null,
+        comparison: null,
+        isNoOp: false,
+        isDowngrade: false,
+      };
+    }
+    target = (releases.find((r) => r.is_stable !== false) ?? releases[0])
+      .version;
+  }
+
+  const comparison = currentVersion
+    ? compareVersions(target, currentVersion)
+    : null;
+  const isNoOp = currentVersion ? versionsEqual(target, currentVersion) : false;
+
+  return {
+    kind: "ok",
+    target,
+    comparison,
+    isNoOp,
+    isDowngrade: comparison !== null && comparison < 0,
+  };
+}
+
+export interface UpgradePollState {
+  /** Resolved target; null when the server resolved "latest" without reporting it. */
+  targetVersion: string | null;
+  /** Version observed before the upgrade was triggered. */
+  initialVersion: string | null;
+  /** Latest current_release_version from the assistant detail endpoint. */
+  observedVersion: string | null;
+  /** Latest upgrade-status in_progress; null when the endpoint is unavailable. */
+  inProgress: boolean | null;
+  /** Whether in_progress === true was ever observed during this poll. */
+  sawInProgress: boolean;
+}
+
+/**
+ * Completion predicate for the platform upgrade poll loop. Pure.
+ *
+ * The primary signal is the DB-backed `current_release_version` (works while
+ * the service group restarts or the assistant sleeps); the upgrade-status
+ * lock is secondary, used only when the target version is unknown.
+ */
+export function evaluateUpgradePoll(
+  state: UpgradePollState,
+): "pending" | "complete" {
+  const {
+    targetVersion,
+    initialVersion,
+    observedVersion,
+    inProgress,
+    sawInProgress,
+  } = state;
+
+  if (targetVersion) {
+    return observedVersion && versionsEqual(observedVersion, targetVersion)
+      ? "complete"
+      : "pending";
+  }
+
+  // Target unknown: a version change from the pre-upgrade value is
+  // definitive on its own — the upgrade can finish before the first poll,
+  // leaving in_progress false without sawInProgress ever being set.
+  if (
+    observedVersion &&
+    initialVersion &&
+    !versionsEqual(observedVersion, initialVersion)
+  ) {
+    return "complete";
+  }
+
+  // Otherwise rely on the in-progress lock releasing (e.g. when the
+  // pre-upgrade version was unknown).
+  if (sawInProgress && inProgress === false) return "complete";
+
+  return "pending";
+}

package/src/lib/version-compat.ts

@@ -0,0 +1,125 @@
+/**
+ * Parse a version string into { major, minor, patch, pre } components.
+ * Handles optional `v`/`V` prefix (e.g., "v1.2.3" or "1.2.3").
+ * Pre-release suffixes are captured (e.g., "0.6.0-staging.5" → pre: "staging.5").
+ * Returns null if the string cannot be parsed as semver.
+ */
+export function parseVersion(
+  version: string,
+): { major: number; minor: number; patch: number; pre: string | null } | null {
+  const stripped = version.replace(/^[vV]/, "");
+  const [core, ...rest] = stripped.split("-");
+  const pre = rest.length > 0 ? rest.join("-") : null;
+  const segments = (core ?? "").split(".");
+
+  if (segments.length < 2) {
+    return null;
+  }
+
+  const major = parseInt(segments[0], 10);
+  const minor = parseInt(segments[1], 10);
+  const patch = segments.length >= 3 ? parseInt(segments[2], 10) : 0;
+
+  if (isNaN(major) || isNaN(minor) || isNaN(patch)) {
+    return null;
+  }
+
+  return { major, minor, patch, pre };
+}
+
+/**
+ * Compare two pre-release strings per semver §11:
+ *   - Dot-separated identifiers compared left to right.
+ *   - Both numeric → compare as integers.
+ *   - Both non-numeric → compare lexically.
+ *   - Numeric vs non-numeric → numeric sorts lower (§11.4.4).
+ *   - Fewer identifiers sorts earlier when all preceding are equal.
+ */
+function comparePreRelease(a: string, b: string): number {
+  const pa = a.split(".");
+  const pb = b.split(".");
+  const len = Math.max(pa.length, pb.length);
+  for (let i = 0; i < len; i++) {
+    if (i >= pa.length) return -1; // a has fewer fields → a < b
+    if (i >= pb.length) return 1;
+    const aIsNum = /^\d+$/.test(pa[i]);
+    const bIsNum = /^\d+$/.test(pb[i]);
+    if (aIsNum && bIsNum) {
+      const diff = Number(pa[i]) - Number(pb[i]);
+      if (diff !== 0) return diff;
+    } else if (aIsNum !== bIsNum) {
+      return aIsNum ? -1 : 1; // numeric < non-numeric per §11.4.4
+    } else {
+      const cmp = (pa[i] ?? "").localeCompare(pb[i] ?? "");
+      if (cmp !== 0) return cmp;
+    }
+  }
+  return 0;
+}
+
+/**
+ * Compare two semver version strings.
+ * Returns negative if a < b, 0 if equal, positive if a > b.
+ *
+ * Handles pre-release suffixes per semver spec:
+ *   - `0.6.0-staging.1 < 0.6.0` (pre-release < release)
+ *   - `0.6.0-staging.1 < 0.6.0-staging.2` (numeric postfix comparison)
+ *
+ * Returns null if either version cannot be parsed.
+ */
+export function compareVersions(a: string, b: string): number | null {
+  const pa = parseVersion(a);
+  const pb = parseVersion(b);
+  if (pa === null || pb === null) return null;
+
+  const majorDiff = pa.major - pb.major;
+  if (majorDiff !== 0) return majorDiff;
+  const minorDiff = pa.minor - pb.minor;
+  if (minorDiff !== 0) return minorDiff;
+  const patchDiff = pa.patch - pb.patch;
+  if (patchDiff !== 0) return patchDiff;
+
+  // Same major.minor.patch — compare pre-release
+  if (pa.pre === null && pb.pre === null) return 0;
+  if (pa.pre !== null && pb.pre === null) return -1; // pre-release < release
+  if (pa.pre === null && pb.pre !== null) return 1;
+  return comparePreRelease(pa.pre!, pb.pre!);
+}
+
+/**
+ * Strip an optional leading `v`/`V` prefix: "v0.7.0" → "0.7.0".
+ */
+export function stripVersionPrefix(version: string): string {
+  return version.replace(/^[vV]/, "");
+}
+
+/**
+ * Check whether two version strings refer to the same version.
+ * Compares via semver when both parse; falls back to prefix-stripped
+ * string equality when either is unparseable.
+ */
+export function versionsEqual(a: string, b: string): boolean {
+  const cmp = compareVersions(a, b);
+  if (cmp !== null) return cmp === 0;
+  return stripVersionPrefix(a) === stripVersionPrefix(b);
+}
+
+/**
+ * Check whether two version strings are compatible.
+ * Compatibility requires matching major AND minor versions.
+ * Patch differences are allowed.
+ * Returns false if either version cannot be parsed.
+ */
+export function isVersionCompatible(
+  clientVersion: string,
+  serviceGroupVersion: string,
+): boolean {
+  const a = parseVersion(clientVersion);
+  const b = parseVersion(serviceGroupVersion);
+
+  if (a === null || b === null) {
+    return false;
+  }
+
+  return a.major === b.major && a.minor === b.minor;
+}

package/src/lib/web-dist.ts

@@ -0,0 +1,48 @@
+import { existsSync } from "node:fs";
+import { createRequire } from "node:module";
+import { dirname, join } from "node:path";
+
+const loadModule = createRequire(import.meta.url);
+
+interface WebDistOptions {
+  execPath?: string;
+  platform?: NodeJS.Platform;
+  resolvePackage?: () => string;
+  startDir?: string;
+}
+
+/** Locate the pre-built web SPA for installed, packaged, or source CLIs. */
+export function findWebDistDir(options: WebDistOptions = {}): string | null {
+  try {
+    const packageJson = (
+      options.resolvePackage ??
+      (() => loadModule.resolve("@mycadet/web/package.json"))
+    )();
+    const distDir = join(dirname(packageJson), "dist");
+    if (existsSync(join(distDir, "index.html"))) {
+      return distDir;
+    }
+  } catch {}
+
+  if ((options.platform ?? process.platform) === "win32") {
+    const runtimeDir = dirname(options.execPath ?? process.execPath);
+    const packagedDist = join(runtimeDir, "web-dist");
+    if (existsSync(join(packagedDist, "index.html"))) {
+      return packagedDist;
+    }
+  }
+
+  let dir = options.startDir ?? import.meta.dir;
+  for (let depth = 0; depth < 8; depth++) {
+    const candidate = join(dir, "clients", "web", "dist", "index.html");
+    if (existsSync(candidate)) {
+      return dirname(candidate);
+    }
+    const parent = dirname(dir);
+    if (parent === dir) {
+      break;
+    }
+    dir = parent;
+  }
+  return null;
+}

package/src/lib/workos-pkce.ts

@@ -0,0 +1,159 @@
+/**
+ * App-held PKCE login against WorkOS User Management (RFC 8252 loopback).
+ */
+
+import crypto from "node:crypto";
+
+import { loopbackSafeFetch } from "./loopback-fetch.js";
+
+const WORKOS_API_BASE_URL = "https://api.workos.com";
+const PROVIDER_ID = "workos";
+const SCOPE = "openid profile email";
+
+// Use a loopback callback: `http://127.0.0.1:*/auth/callback`
+export const CALLBACK_PATH = "/auth/callback";
+
+export interface PkcePair {
+  verifier: string;
+  challenge: string;
+}
+
+export function generatePkcePair(): PkcePair {
+  const verifier = crypto.randomBytes(32).toString("base64url");
+  const challenge = crypto
+    .createHash("sha256")
+    .update(verifier)
+    .digest("base64url");
+  return { verifier, challenge };
+}
+
+export interface AuthorizeUrlOptions {
+  clientId: string;
+  redirectUri: string;
+  challenge: string;
+  state: string;
+  loginHint?: string;
+}
+
+export function buildAuthorizeUrl(options: AuthorizeUrlOptions): string {
+  const url = new URL("/user_management/authorize", WORKOS_API_BASE_URL);
+  url.searchParams.set("client_id", options.clientId);
+  url.searchParams.set("redirect_uri", options.redirectUri);
+  url.searchParams.set("response_type", "code");
+  url.searchParams.set("scope", SCOPE);
+  url.searchParams.set("code_challenge", options.challenge);
+  url.searchParams.set("code_challenge_method", "S256");
+  url.searchParams.set("state", options.state);
+  // No `prompt`: lets the browser's existing IdP session be reused.
+  url.searchParams.set("provider", "authkit");
+  if (options.loginHint) url.searchParams.set("login_hint", options.loginHint);
+  return url.toString();
+}
+
+interface HeadlessProviderEntry {
+  id: string;
+  name?: string;
+  client_id?: string;
+  flows?: string[];
+  openid_configuration_url?: string;
+}
+
+/**
+ * Pick the OAuth2 WorkOS provider from the headless config. During the
+ * coexistence window two entries share the "workos-oidc" id; the usable one
+ * has token auth and no OIDC discovery URL. Null if none.
+ */
+export function selectWorkosClientId(
+  providers: HeadlessProviderEntry[],
+): string | null {
+  const entry = providers.find(
+    (p) =>
+      !p.openid_configuration_url &&
+      (p.flows ?? []).includes("provider_token") &&
+      typeof p.client_id === "string",
+  );
+  return entry?.client_id ?? null;
+}
+
+export async function fetchWorkosClientId(
+  platformUrl: string,
+): Promise<string> {
+  const url = `${new URL(platformUrl).origin}/_allauth/app/v1/config`;
+  const response = await loopbackSafeFetch(url);
+  if (!response.ok) {
+    throw new Error(`Failed to fetch auth config (${response.status})`);
+  }
+  const body = (await response.json()) as {
+    data?: { socialaccount?: { providers?: HeadlessProviderEntry[] } };
+  };
+  const clientId = selectWorkosClientId(
+    body.data?.socialaccount?.providers ?? [],
+  );
+  if (!clientId) {
+    throw new Error(
+      "Platform does not advertise a token-auth WorkOS provider; cannot start PKCE login.",
+    );
+  }
+  return clientId;
+}
+
+/** Exchange the authorization code at WorkOS as a public client. */
+export async function exchangeCodeWithWorkos(options: {
+  clientId: string;
+  code: string;
+  verifier: string;
+}): Promise<string> {
+  const response = await loopbackSafeFetch(
+    `${WORKOS_API_BASE_URL}/user_management/authenticate`,
+    {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        client_id: options.clientId,
+        grant_type: "authorization_code",
+        code: options.code,
+        code_verifier: options.verifier,
+      }),
+    },
+  );
+  if (!response.ok) {
+    const body = await response.text();
+    throw new Error(
+      `WorkOS code exchange failed (${response.status}): ${body}`,
+    );
+  }
+  const data = (await response.json()) as { access_token?: string };
+  if (!data.access_token) {
+    throw new Error("WorkOS code exchange returned no access token.");
+  }
+  return data.access_token;
+}
+
+/** Exchange the WorkOS access token for a platform session token. */
+export async function exchangeAccessTokenForSession(
+  platformUrl: string,
+  clientId: string,
+  accessToken: string,
+): Promise<string> {
+  const url = `${new URL(platformUrl).origin}/_allauth/app/v1/auth/provider/token`;
+  const response = await loopbackSafeFetch(url, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({
+      provider: PROVIDER_ID,
+      process: "login",
+      token: { client_id: clientId, access_token: accessToken },
+    }),
+  });
+  if (!response.ok) {
+    const body = await response.text();
+    throw new Error(`Session exchange failed (${response.status}): ${body}`);
+  }
+  const data = (await response.json()) as {
+    meta?: { session_token?: string };
+  };
+  if (!data.meta?.session_token) {
+    throw new Error("Session exchange returned no session token.");
+  }
+  return data.meta.session_token;
+}

package/src/lib/xdg-log.ts

@@ -0,0 +1,144 @@
+import type { ChildProcess } from "child_process";
+import {
+  closeSync,
+  copyFileSync,
+  existsSync,
+  mkdirSync,
+  openSync,
+  statSync,
+  writeFileSync,
+  writeSync,
+} from "fs";
+import { join } from "path";
+
+import { getLogDir as getEnvironmentLogDir } from "./environments/paths.js";
+import { getCurrentEnvironment } from "./environments/resolve.js";
+
+/** Regex matching pino-pretty's short time prefix, e.g. `[12:07:37.467] `. */
+const PINO_TIME_RE = /^\[\d{2}:\d{2}:\d{2}\.\d{3}\]\s*/;
+
+/**
+ * Returns the XDG-compatible log directory for Cadet CLI logs.
+ *
+ * Environment-aware: production uses `$XDG_CONFIG_HOME/cadet/logs`,
+ * non-production environments use `$XDG_CONFIG_HOME/cadet-<env>/logs`.
+ */
+export function getLogDir(): string {
+  return getEnvironmentLogDir(getCurrentEnvironment());
+}
+
+/** Open (or create) a log file in append mode, returning the file descriptor.
+ *  Creates the parent directory if it doesn't exist. Returns "ignore" if the
+ *  directory or file cannot be created (permissions, read-only filesystem, etc.)
+ *  so that callers can fall back to discarding output instead of aborting. */
+export function openLogFile(name: string): number | "ignore" {
+  try {
+    const dir = getLogDir();
+    mkdirSync(dir, { recursive: true });
+    return openSync(join(dir, name), "a");
+  } catch {
+    return "ignore";
+  }
+}
+
+/** Truncate (or create) a log file so each session starts fresh. */
+export function resetLogFile(name: string): void {
+  try {
+    const dir = getLogDir();
+    mkdirSync(dir, { recursive: true });
+    writeFileSync(join(dir, name), "");
+  } catch {
+    /* best-effort */
+  }
+}
+
+/**
+ * Copy the current log file into `destDir` with a timestamped name so that
+ * previous session logs are preserved for debugging. No-op when the source
+ * file is missing or empty, or when `destDir` does not already exist.
+ */
+export function archiveLogFile(name: string, destDir: string): void {
+  try {
+    if (!existsSync(destDir)) return;
+    const srcPath = join(getLogDir(), name);
+    if (!existsSync(srcPath) || statSync(srcPath).size === 0) return;
+
+    const ts = new Date().toISOString().replace(/[:.]/g, "-");
+    const base = name.replace(/\.log$/, "");
+    copyFileSync(srcPath, join(destDir, `${base}-${ts}.log`));
+  } catch {
+    /* best-effort */
+  }
+}
+
+/** Close a file descriptor returned by openLogFile (no-op for "ignore"). */
+export function closeLogFile(fd: number | "ignore"): void {
+  if (typeof fd === "number") {
+    try {
+      closeSync(fd);
+    } catch {
+      /* best-effort */
+    }
+  }
+}
+
+/** Write a string to a file descriptor returned by openLogFile (no-op for "ignore"). */
+export function writeToLogFile(fd: number | "ignore", msg: string): void {
+  if (typeof fd === "number") {
+    try {
+      writeSync(fd, msg);
+    } catch {
+      /* best-effort */
+    }
+  }
+}
+
+/** Pipe a child process's stdout/stderr to a shared log file descriptor,
+ *  prefixing each line with an ISO timestamp and tag (e.g. "[daemon]").
+ *  Strips pino-pretty's redundant short time prefix when present.
+ *  Streams are unref'd so they don't prevent the parent from exiting.
+ *  The fd is closed automatically when both streams end. */
+export function pipeToLogFile(
+  child: ChildProcess,
+  fd: number | "ignore",
+  tag: string,
+): void {
+  if (fd === "ignore") return;
+  const numFd: number = fd;
+  const tagLabel = `[${tag}]`;
+  const streams = [child.stdout, child.stderr].filter(Boolean);
+  let ended = 0;
+
+  function onDone() {
+    ended++;
+    if (ended >= streams.length) {
+      try {
+        closeSync(numFd);
+      } catch {
+        /* best-effort */
+      }
+    }
+  }
+
+  for (const stream of streams) {
+    if (!stream) continue;
+    (stream as NodeJS.ReadableStream & { unref?: () => void }).unref?.();
+    stream.on("data", (chunk: Buffer) => {
+      const text = chunk.toString();
+      const lines = text.split("\n");
+      for (let i = 0; i < lines.length; i++) {
+        if (i === lines.length - 1 && lines[i] === "") break;
+        const nl = i < lines.length - 1 ? "\n" : "";
+        const stripped = lines[i].replace(PINO_TIME_RE, "");
+        const prefix = `${new Date().toISOString()} ${tagLabel} `;
+        try {
+          writeSync(numFd, prefix + stripped + nl);
+        } catch {
+          /* best-effort */
+        }
+      }
+    });
+    stream.on("end", onDone);
+    stream.on("error", onDone);
+  }
+}

package/src/shared/provider-env-vars.ts

@@ -0,0 +1,63 @@
+/**
+ * Provider API key environment variable names, keyed by provider ID.
+ *
+ * Two sources are merged into a single combined map. Both are locally-
+ * maintained mirrors of canonical catalogs in `assistant/src/providers/`
+ * — the CLI does not import from `assistant/src/`, so drift is caught by
+ * dedicated parity tests:
+ *
+ *   1. LLM-provider env vars — mirrors `PROVIDER_CATALOG` entries with an
+ *      `envVar`. Drift guard: `cli/src/__tests__/llm-provider-env-var-parity.test.ts`.
+ *   2. Search-provider env vars — mirrors `SEARCH_PROVIDER_CATALOG`
+ *      entries with an `envVar`. Drift guard:
+ *      `cli/src/__tests__/search-provider-env-var-parity.test.ts`.
+ *
+ * The combined map is what cloud-infra code (docker.ts, aws.ts, gcp.ts)
+ * iterates to forward provider API keys from the caller's environment into
+ * containers / VMs. Keeping both kinds of provider env vars in one map means
+ * the infra call sites don't need to know which kind is which — they just
+ * forward every value whose env var is set.
+ */
+
+/** LLM provider env var names. Mirrors `PROVIDER_CATALOG` entries with an `envVar`. */
+export const LLM_PROVIDER_ENV_VAR_NAMES: Record<string, string> = {
+  anthropic: "ANTHROPIC_API_KEY",
+  openai: "OPENAI_API_KEY",
+  gemini: "GEMINI_API_KEY",
+  fireworks: "FIREWORKS_API_KEY",
+  openrouter: "OPENROUTER_API_KEY",
+  "vercel-ai-gateway": "AI_GATEWAY_API_KEY",
+  minimax: "MINIMAX_API_KEY",
+  atlascloud: "ATLASCLOUD_API_KEY",
+  together: "TOGETHER_API_KEY",
+  litellm: "LITELLM_API_KEY",
+  opencode: "OPENCODE_API_KEY",
+  baseten: "BASETEN_API_KEY",
+  ionet: "IONET_API_KEY",
+  poolside: "POOLSIDE_API_KEY",
+  typesafe: "TYPESAFE_API_KEY",
+};
+
+/** Search-provider env var names. Mirrors `SEARCH_PROVIDER_CATALOG` BYOK entries. */
+export const SEARCH_PROVIDER_ENV_VAR_NAMES: Record<string, string> = {
+  perplexity: "PERPLEXITY_API_KEY",
+  brave: "BRAVE_API_KEY",
+  tavily: "TAVILY_API_KEY",
+  firecrawl: "FIRECRAWL_API_KEY",
+  keenable: "KEENABLE_API_KEY",
+  fastcrw: "FASTCRW_API_KEY",
+  searxng: "SEARXNG_API_KEY",
+  tinyfish: "TINYFISH_API_KEY",
+  exa: "EXA_API_KEY",
+  serply: "SERPLY_API_KEY",
+};
+
+/**
+ * Combined provider env var names — the union of LLM and search providers.
+ * Used by the cloud-infra flows (docker/aws/gcp) to forward every supported
+ * provider API key from the caller's environment.
+ */
+export const PROVIDER_ENV_VAR_NAMES: Record<string, string> = {
+  ...LLM_PROVIDER_ENV_VAR_NAMES,
+  ...SEARCH_PROVIDER_ENV_VAR_NAMES,
+};

package/src/types/sh.d.ts

@@ -0,0 +1,4 @@
+declare module "*.sh" {
+  const content: string;
+  export default content;
+}

package/tsconfig.json

@@ -0,0 +1,17 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "noEmit": true,
+    "jsx": "react-jsx",
+    "types": ["bun"]
+  },
+  "include": ["src/**/*", "src/**/*.tsx"],
+  "exclude": ["node_modules"]
+}