@readwise/cli 0.3.0

package/dist/tui/index.d.ts

@@ -0,0 +1,2 @@
+import type { ToolDef } from "../config.js";
+export declare function startTui(tools: ToolDef[], token: string, authType: "oauth" | "token"): Promise<void>;

package/dist/tui/index.js

@@ -0,0 +1,11 @@
+import { enterFullScreen, exitFullScreen } from "./term.js";
+import { runApp } from "./app.js";
+export async function startTui(tools, token, authType) {
+    enterFullScreen();
+    try {
+        await runApp(tools);
+    }
+    finally {
+        exitFullScreen();
+    }
+}

package/dist/tui/logo.d.ts

@@ -0,0 +1 @@
+export declare const LOGO: string[];

package/dist/tui/logo.js

@@ -0,0 +1,16 @@
+export const LOGO = [
+    "╔════════════════════════╗",
+    "║░░░░░░░░░░░░░░░░░░░░░░░░║",
+    "║░░░░░░░░░░░░░░░░░░░░░░░░║",
+    "║░░░░░▓▓▓▓▓▓▓▓▓▓▓░░░░░░░░║",
+    "║░░░░░░▓▓▓▓▓▓▓▓▓▓▓▓░░░░░░║",
+    "║░░░░░░▓▓▓▓▓▓░░▓▓▓▓▓░░░░░║",
+    "║░░░░░░▓▓▓▓▓▓▓▓▓▓▓▓░░░░░░║",
+    "║░░░░░░▓▓▓▓▓▓▓▓▓▓░░░░░░░░║",
+    "║░░░░░░▓▓▓▓▓░▓▓▓▓░░░░░░░░║",
+    "║░░░░░░▓▓▓▓▓░░▓▓▓▓▓░░░░░░║",
+    "║░░░░░▓▓▓▓▓▓▓░░▓▓▓▓▓▓░░░░║",
+    "║░░░░░░░░░░░░░░░░░░░░░░░░║",
+    "║░░░░░░░░░░░░░░░░░░░░░░░░║",
+    "╚════════════════════════╝",
+];

package/dist/tui/term.d.ts

@@ -0,0 +1,32 @@
+export declare const style: {
+    bold: (s: string) => string;
+    dim: (s: string) => string;
+    inverse: (s: string) => string;
+    yellow: (s: string) => string;
+    red: (s: string) => string;
+    green: (s: string) => string;
+    cyan: (s: string) => string;
+    boldYellow: (s: string) => string;
+    blue: (s: string) => string;
+};
+export declare function enterFullScreen(): void;
+export declare function exitFullScreen(): void;
+/** Paint lines to terminal without flicker: cursor home → overwrite each line → clear remainder */
+export declare function paint(lines: string[]): void;
+export declare function screenSize(): {
+    cols: number;
+    rows: number;
+};
+export interface KeyEvent {
+    raw: string;
+    name: string;
+    shift: boolean;
+    ctrl: boolean;
+}
+export declare function parseKey(data: Buffer): KeyEvent;
+/** Strip ANSI escape codes to get visible character count */
+export declare function stripAnsi(s: string): string;
+/** Skip `offset` visible characters, preserving ANSI state, then return the rest */
+export declare function ansiSlice(s: string, offset: number): string;
+/** Pad/truncate a string to a visible width (ANSI-aware) */
+export declare function fitWidth(s: string, width: number): string;

package/dist/tui/term.js

@@ -0,0 +1,147 @@
+// Low-level terminal utilities for flicker-free full-screen rendering.
+// Instead of clearing and rewriting (which blinks), we position the cursor
+// at home and overwrite in-place — content is never erased before being replaced.
+const ESC = "\x1b";
+// --- ANSI helpers ---
+export const style = {
+    bold: (s) => `${ESC}[1m${s}${ESC}[22m`,
+    dim: (s) => `${ESC}[2m${s}${ESC}[22m`,
+    inverse: (s) => `${ESC}[7m${s}${ESC}[27m`,
+    yellow: (s) => `${ESC}[33m${s}${ESC}[39m`,
+    red: (s) => `${ESC}[31m${s}${ESC}[39m`,
+    green: (s) => `${ESC}[32m${s}${ESC}[39m`,
+    cyan: (s) => `${ESC}[36m${s}${ESC}[39m`,
+    boldYellow: (s) => `${ESC}[1;33m${s}${ESC}[22;39m`,
+    blue: (s) => `${ESC}[38;2;60;110;253m${s}${ESC}[39m`,
+};
+// --- Screen control ---
+export function enterFullScreen() {
+    process.stdout.write(`${ESC}[?1049h`); // alternate screen buffer
+    process.stdout.write(`${ESC}[?25l`); // hide cursor
+    process.stdout.write(`${ESC}[H`); // cursor home
+}
+export function exitFullScreen() {
+    process.stdout.write(`${ESC}[?25h`); // show cursor
+    process.stdout.write(`${ESC}[?1049l`); // restore screen buffer
+}
+/** Paint lines to terminal without flicker: cursor home → overwrite each line → clear remainder */
+export function paint(lines) {
+    const rows = process.stdout.rows ?? 24;
+    let out = `${ESC}[H`; // cursor home
+    const count = Math.min(lines.length, rows);
+    for (let i = 0; i < count; i++) {
+        out += lines[i] + `${ESC}[K\n`; // line content + clear to end of line
+    }
+    // Clear any remaining lines below content
+    if (count < rows) {
+        out += `${ESC}[J`; // clear from cursor to end of screen
+    }
+    process.stdout.write(out);
+}
+export function screenSize() {
+    return { cols: process.stdout.columns ?? 80, rows: process.stdout.rows ?? 24 };
+}
+export function parseKey(data) {
+    const s = data.toString("utf-8");
+    const ctrl = s.length === 1 && s.charCodeAt(0) < 32;
+    // Escape sequences
+    if (s === `${ESC}[A`)
+        return { raw: s, name: "up", shift: false, ctrl: false };
+    if (s === `${ESC}[B`)
+        return { raw: s, name: "down", shift: false, ctrl: false };
+    if (s === `${ESC}[C`)
+        return { raw: s, name: "right", shift: false, ctrl: false };
+    if (s === `${ESC}[D`)
+        return { raw: s, name: "left", shift: false, ctrl: false };
+    if (s === `${ESC}[5~`)
+        return { raw: s, name: "pageup", shift: false, ctrl: false };
+    if (s === `${ESC}[6~`)
+        return { raw: s, name: "pagedown", shift: false, ctrl: false };
+    if (s === `${ESC}[Z`)
+        return { raw: s, name: "tab", shift: true, ctrl: false };
+    if (s === ESC || s === `${ESC}${ESC}`)
+        return { raw: s, name: "escape", shift: false, ctrl: false };
+    // Shift+Enter sequences
+    if (s === `${ESC}[13;2u`)
+        return { raw: s, name: "return", shift: true, ctrl: false }; // CSI u / kitty
+    if (s === `${ESC}[27;2;13~`)
+        return { raw: s, name: "return", shift: true, ctrl: false }; // xterm
+    if (s === `${ESC}OM`)
+        return { raw: s, name: "return", shift: true, ctrl: false }; // misc terminals
+    // Single characters
+    if (s === "\r" || s === "\n")
+        return { raw: s, name: "return", shift: false, ctrl: false };
+    if (s === "\t")
+        return { raw: s, name: "tab", shift: false, ctrl: false };
+    if (s === "\x7f" || s === "\b")
+        return { raw: s, name: "backspace", shift: false, ctrl: false };
+    if (s === "\x03")
+        return { raw: s, name: "c", shift: false, ctrl: true }; // Ctrl+C
+    if (s === "\x04")
+        return { raw: s, name: "d", shift: false, ctrl: true }; // Ctrl+D
+    if (ctrl) {
+        return { raw: s, name: String.fromCharCode(s.charCodeAt(0) + 96), shift: false, ctrl: true };
+    }
+    return { raw: s, name: s, shift: false, ctrl: false };
+}
+/** Strip ANSI escape codes to get visible character count */
+export function stripAnsi(s) {
+    return s.replace(/\x1b\[[0-9;]*m/g, "");
+}
+/** Skip `offset` visible characters, preserving ANSI state, then return the rest */
+export function ansiSlice(s, offset) {
+    if (offset <= 0)
+        return s;
+    // Collect ANSI sequences encountered while skipping so we can replay them
+    let activeAnsi = "";
+    let count = 0;
+    let i = 0;
+    while (i < s.length && count < offset) {
+        if (s[i] === "\x1b") {
+            const end = s.indexOf("m", i);
+            if (end >= 0) {
+                activeAnsi += s.slice(i, end + 1);
+                i = end + 1;
+                continue;
+            }
+        }
+        count++;
+        i++;
+    }
+    // Consume any ANSI codes right at the boundary
+    while (i < s.length && s[i] === "\x1b") {
+        const end = s.indexOf("m", i);
+        if (end >= 0) {
+            activeAnsi += s.slice(i, end + 1);
+            i = end + 1;
+        }
+        else
+            break;
+    }
+    return activeAnsi + s.slice(i);
+}
+/** Pad/truncate a string to a visible width (ANSI-aware) */
+export function fitWidth(s, width) {
+    const visible = stripAnsi(s);
+    if (visible.length >= width) {
+        // Truncate — need to be careful with ANSI codes
+        let count = 0;
+        let i = 0;
+        while (i < s.length && count < width) {
+            if (s[i] === "\x1b") {
+                const end = s.indexOf("m", i);
+                if (end >= 0) {
+                    i = end + 1;
+                    continue;
+                }
+            }
+            count++;
+            i++;
+        }
+        // Include any trailing ANSI reset codes
+        const rest = s.slice(i);
+        const resets = rest.match(/^(\x1b\[[0-9;]*m)*/)?.[0] || "";
+        return s.slice(0, i) + resets;
+    }
+    return s + " ".repeat(width - visible.length);
+}

package/dist/version.d.ts

@@ -0,0 +1 @@
+export declare const VERSION: string;

package/dist/version.js

@@ -0,0 +1,4 @@
+import { createRequire } from "node:module";
+const require = createRequire(import.meta.url);
+const pkg = require("../package.json");
+export const VERSION = pkg.version;

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "@readwise/cli",
+  "version": "0.3.0",
+  "description": "Command-line interface for Readwise and Reader",
+  "type": "module",
+  "bin": {
+    "readwise": "./dist/index.js"
+  },
+  "files": [
+    "dist",
+    "src",
+    "README.md",
+    "tsconfig.json"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsx src/index.ts",
+    "start": "node dist/index.js"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "latest",
+    "commander": "^13",
+    "open": "^10"
+  },
+  "devDependencies": {
+    "typescript": "^5",
+    "@types/node": "^22",
+    "tsx": "^4"
+  }
+}

package/src/auth.ts

@@ -0,0 +1,248 @@
+import { createServer } from "node:http";
+import { randomBytes, createHash } from "node:crypto";
+import { URL } from "node:url";
+import open from "open";
+import { loadConfig, saveConfig, type Config } from "./config.js";
+
+const DISCOVERY_URL = "https://readwise.io/o/.well-known/oauth-authorization-server";
+const REDIRECT_URI = "http://localhost:6274/callback";
+const SCOPES = "openid read write";
+
+interface OAuthMetadata {
+  authorization_endpoint: string;
+  token_endpoint: string;
+  registration_endpoint: string;
+}
+
+async function discover(): Promise<OAuthMetadata> {
+  const res = await fetch(DISCOVERY_URL);
+  if (!res.ok) throw new Error(`OAuth discovery failed: ${res.status} ${res.statusText}`);
+  return (await res.json()) as OAuthMetadata;
+}
+
+async function registerClient(registrationEndpoint: string): Promise<{ client_id: string; client_secret: string }> {
+  const res = await fetch(registrationEndpoint, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({
+      client_name: "readwise-cli",
+      redirect_uris: [REDIRECT_URI],
+      grant_types: ["authorization_code", "refresh_token"],
+      token_endpoint_auth_method: "client_secret_basic",
+    }),
+  });
+  if (!res.ok) {
+    const body = await res.text();
+    throw new Error(`Client registration failed: ${res.status} ${body}`);
+  }
+  return (await res.json()) as { client_id: string; client_secret: string };
+}
+
+function generatePKCE(): { verifier: string; challenge: string } {
+  const verifier = randomBytes(48).toString("base64url");
+  const challenge = createHash("sha256").update(verifier).digest("base64url");
+  return { verifier, challenge };
+}
+
+function waitForCallback(state: string): Promise<string> {
+  return new Promise((resolve, reject) => {
+    let timeout: NodeJS.Timeout;
+
+    const cleanup = () => {
+      clearTimeout(timeout);
+      server.close();
+    };
+
+    const server = createServer((req, res) => {
+      const url = new URL(req.url!, `http://localhost:6274`);
+      if (url.pathname !== "/callback") {
+        res.writeHead(404);
+        res.end();
+        return;
+      }
+
+      const code = url.searchParams.get("code");
+      const returnedState = url.searchParams.get("state");
+      const error = url.searchParams.get("error");
+
+      if (error) {
+        res.writeHead(200, { "Content-Type": "text/html" });
+        res.end(`<html><body><h1>Login failed</h1><p>${error}</p><p>You can close this tab.</p></body></html>`);
+        cleanup();
+        reject(new Error(`OAuth error: ${error}`));
+        return;
+      }
+
+      if (!code || returnedState !== state) {
+        res.writeHead(400, { "Content-Type": "text/html" });
+        res.end(`<html><body><h1>Invalid callback</h1><p>You can close this tab.</p></body></html>`);
+        cleanup();
+        reject(new Error("Invalid callback: missing code or state mismatch"));
+        return;
+      }
+
+      res.writeHead(200, { "Content-Type": "text/html" });
+      res.end(`<html><body><h1>Login successful!</h1><p>You can close this tab and return to the terminal.</p></body></html>`);
+      cleanup();
+      resolve(code);
+    });
+
+    server.listen(6274, () => {
+      // Server ready
+    });
+
+    server.on("error", (err) => {
+      clearTimeout(timeout);
+      reject(new Error(`Failed to start callback server: ${err.message}`));
+    });
+
+    // Timeout after 2 minutes
+    timeout = setTimeout(() => {
+      server.close();
+      reject(new Error("Login timed out — no callback received within 2 minutes"));
+    }, 120_000);
+  });
+}
+
+async function exchangeToken(
+  tokenEndpoint: string,
+  code: string,
+  clientId: string,
+  clientSecret: string,
+  codeVerifier: string,
+): Promise<{ access_token: string; refresh_token: string; expires_in: number }> {
+  const res = await fetch(tokenEndpoint, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/x-www-form-urlencoded",
+      Authorization: `Basic ${Buffer.from(`${clientId}:${clientSecret}`).toString("base64")}`,
+    },
+    body: new URLSearchParams({
+      grant_type: "authorization_code",
+      code,
+      redirect_uri: REDIRECT_URI,
+      code_verifier: codeVerifier,
+    }),
+  });
+  if (!res.ok) {
+    const body = await res.text();
+    throw new Error(`Token exchange failed: ${res.status} ${body}`);
+  }
+  return (await res.json()) as { access_token: string; refresh_token: string; expires_in: number };
+}
+
+export async function login(): Promise<void> {
+  console.log("Discovering OAuth endpoints...");
+  const metadata = await discover();
+
+  let config = await loadConfig();
+
+  // Register client if needed
+  if (!config.client_id || !config.client_secret) {
+    console.log("Registering client...");
+    const { client_id, client_secret } = await registerClient(metadata.registration_endpoint);
+    config.client_id = client_id;
+    config.client_secret = client_secret;
+    await saveConfig(config);
+  }
+
+  const { verifier, challenge } = generatePKCE();
+  const state = randomBytes(16).toString("hex");
+
+  const authUrl = new URL(metadata.authorization_endpoint);
+  authUrl.searchParams.set("response_type", "code");
+  authUrl.searchParams.set("client_id", config.client_id);
+  authUrl.searchParams.set("redirect_uri", REDIRECT_URI);
+  authUrl.searchParams.set("scope", SCOPES);
+  authUrl.searchParams.set("code_challenge", challenge);
+  authUrl.searchParams.set("code_challenge_method", "S256");
+  authUrl.searchParams.set("state", state);
+
+  // Start callback server before opening browser
+  const codePromise = waitForCallback(state);
+
+  console.log("Opening browser for authentication...");
+  await open(authUrl.toString());
+
+  const code = await codePromise;
+
+  console.log("Exchanging authorization code for tokens...");
+  const tokens = await exchangeToken(
+    metadata.token_endpoint,
+    code,
+    config.client_id,
+    config.client_secret!,
+    verifier,
+  );
+
+  config.access_token = tokens.access_token;
+  config.refresh_token = tokens.refresh_token;
+  config.expires_at = Date.now() + tokens.expires_in * 1000;
+  config.auth_type = "oauth";
+  await saveConfig(config);
+
+  console.log("Login successful! Tokens saved to ~/.readwise-cli.json");
+}
+
+export async function loginWithToken(token: string): Promise<void> {
+  const config = await loadConfig();
+  config.access_token = token;
+  config.auth_type = "token";
+  delete config.refresh_token;
+  delete config.expires_at;
+  delete config.client_id;
+  delete config.client_secret;
+  await saveConfig(config);
+
+  console.log("Token saved to ~/.readwise-cli.json");
+}
+
+export async function ensureValidToken(): Promise<{ token: string; authType: "oauth" | "token" }> {
+  const config = await loadConfig();
+
+  if (!config.access_token) {
+    throw new Error("Not logged in. Run `readwise-cli login` or `readwise-cli login-with-token <token>` first.");
+  }
+
+  const authType = config.auth_type ?? "oauth";
+
+  // Access tokens don't expire and don't need refresh
+  if (authType === "token") {
+    return { token: config.access_token, authType };
+  }
+
+  // Refresh if expired or expiring within 60s
+  if (config.expires_at && Date.now() > config.expires_at - 60_000) {
+    if (!config.refresh_token || !config.client_id || !config.client_secret) {
+      throw new Error("Cannot refresh token — missing credentials. Run `readwise-cli login` again.");
+    }
+
+    console.error("Refreshing access token...");
+    const metadata = await discover();
+
+    const res = await fetch(metadata.token_endpoint, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/x-www-form-urlencoded",
+        Authorization: `Basic ${Buffer.from(`${config.client_id}:${config.client_secret}`).toString("base64")}`,
+      },
+      body: new URLSearchParams({
+        grant_type: "refresh_token",
+        refresh_token: config.refresh_token,
+      }),
+    });
+
+    if (!res.ok) {
+      const body = await res.text();
+      throw new Error(`Token refresh failed: ${res.status} ${body}. Run \`readwise-cli login\` again.`);
+    }
+
+    const tokens = (await res.json()) as { access_token: string; refresh_token?: string; expires_in: number };
+    config.access_token = tokens.access_token;
+    if (tokens.refresh_token) config.refresh_token = tokens.refresh_token;
+    config.expires_at = Date.now() + tokens.expires_in * 1000;
+    await saveConfig(config);
+  }
+
+  return { token: config.access_token, authType };
+}

package/src/commands.ts

@@ -0,0 +1,158 @@
+import { Command } from "commander";
+import { ensureValidToken } from "./auth.js";
+import { callTool } from "./mcp.js";
+import type { ToolDef, SchemaProperty } from "./config.js";
+
+export function toolNameToCommand(name: string): string {
+  return name.replace(/_/g, "-");
+}
+
+export function resolveRef(prop: SchemaProperty, defs?: Record<string, SchemaProperty>): SchemaProperty {
+  if (prop.$ref && defs) {
+    const name = prop.$ref.replace("#/$defs/", "");
+    const resolved = defs[name];
+    if (resolved) return { ...resolved, description: prop.description || resolved.description };
+  }
+  return prop;
+}
+
+export function resolveProperty(prop: SchemaProperty, defs?: Record<string, SchemaProperty>): SchemaProperty {
+  let p = resolveRef(prop, defs);
+  if (p.anyOf) {
+    const nonNull = p.anyOf.find((v) => v.type !== "null");
+    if (nonNull) {
+      p = { ...p, ...resolveRef(nonNull, defs), anyOf: undefined };
+    }
+  }
+  // Resolve items.$ref for array types
+  if (p.type === "array" && p.items) {
+    p = { ...p, items: resolveRef(p.items, defs) };
+    // Also resolve anyOf inside items (e.g. items wrapped in anyOf)
+    if (p.items?.anyOf) {
+      const nonNull = p.items.anyOf.find((v) => v.type !== "null");
+      if (nonNull) {
+        const resolvedItem = resolveRef(nonNull, defs);
+        p = { ...p, items: { ...p.items, ...resolvedItem, anyOf: undefined } };
+      }
+    }
+  }
+  return p;
+}
+
+function optionFlag(name: string, prop: SchemaProperty): string {
+  const flag = `--${name.replace(/_/g, "-")}`;
+
+  if (prop.type === "boolean") {
+    return flag;
+  }
+  return `${flag} <value>`;
+}
+
+function parseValue(value: string, prop: SchemaProperty): unknown {
+  if (prop.type === "integer" || prop.type === "number") {
+    const n = Number(value);
+    if (isNaN(n)) throw new Error(`Expected a number for value: ${value}`);
+    return n;
+  }
+  if (prop.type === "array") {
+    // Try JSON first, then comma-separated
+    try {
+      const parsed = JSON.parse(value);
+      if (Array.isArray(parsed)) return parsed;
+    } catch {
+      // fall through
+    }
+    return value.split(",").map((s) => s.trim());
+  }
+  if (prop.type === "boolean") {
+    return true;
+  }
+  return value;
+}
+
+export function displayResult(result: { content: Array<{ type: string; text?: string }>; structuredContent?: Record<string, unknown>; isError?: boolean }, json: boolean): void {
+  if (result.isError) {
+    for (const item of result.content) {
+      if (item.text) {
+        process.stderr.write(`\x1b[31mError: ${item.text}\x1b[0m\n`);
+      }
+    }
+    process.exitCode = 1;
+    return;
+  }
+
+  // Prefer text content; fall back to structuredContent for empty results
+  let printed = false;
+  for (const item of result.content) {
+    if (item.type === "text" && item.text) {
+      printed = true;
+      if (json) {
+        process.stdout.write(item.text + "\n");
+      } else {
+        try {
+          const parsed = JSON.parse(item.text);
+          console.log(JSON.stringify(parsed, null, 2));
+        } catch {
+          console.log(item.text);
+        }
+      }
+    }
+  }
+
+  if (!printed && result.structuredContent) {
+    const data = result.structuredContent;
+    if (json) {
+      process.stdout.write(JSON.stringify(data) + "\n");
+    } else {
+      console.log(JSON.stringify(data, null, 2));
+    }
+  }
+}
+
+export function registerTools(program: Command, tools: ToolDef[]): void {
+  for (const tool of tools) {
+    const cmd = program
+      .command(toolNameToCommand(tool.name))
+      .description(tool.description || "");
+
+    const properties = tool.inputSchema.properties || {};
+    const required = new Set(tool.inputSchema.required || []);
+    const defs = tool.inputSchema.$defs;
+
+    for (const [propName, rawProp] of Object.entries(properties)) {
+      const prop = resolveProperty(rawProp, defs);
+      const flag = optionFlag(propName, prop);
+      const parts: string[] = [];
+      if (prop.description) parts.push(prop.description);
+      if (required.has(propName)) parts.push("(required)");
+      const enumValues = prop.enum || prop.items?.enum;
+      if (enumValues) parts.push(`[${enumValues.join(", ")}]`);
+      if (prop.default !== undefined) parts.push(`(default: ${JSON.stringify(prop.default)})`);
+
+      cmd.option(flag, parts.join(" ") || undefined);
+    }
+
+    cmd.action(async (options: Record<string, string>) => {
+      try {
+        const { token, authType } = await ensureValidToken();
+
+        // Convert commander options back to tool arguments
+        const args: Record<string, unknown> = {};
+        for (const [propName, rawProp] of Object.entries(properties)) {
+          const prop = resolveProperty(rawProp, defs);
+          const camelKey = propName.replace(/_/g, "-").replace(/-([a-z])/g, (_, c: string) => c.toUpperCase());
+          const value = options[camelKey];
+          if (value !== undefined) {
+            args[propName] = parseValue(String(value), prop);
+          }
+        }
+
+        const result = await callTool(token, authType, tool.name, args);
+        displayResult(result, program.opts().json || false);
+      } catch (err) {
+        process.stderr.write(`\x1b[31m${(err as Error).message}\x1b[0m\n`);
+        process.exitCode = 1;
+      }
+    });
+  }
+}