pi-yandex-bridge 0.2.9 → 0.3.1

package/README.md

@@ -47,3 +47,44 @@ export YANDEX_FOLDER_ID="your-folder-id"
 ```
 
 Models are fetched at startup using the API key. You can generate an API key in the [Yandex AI Studio](https://aistudio.yandex.ru) or in the Yandex Cloud console under **Service accounts → your account → API keys**.
+
+## Development & Testing
+
+### Run tests
+
+```sh
+bun test
+```
+
+Tests cover:
+- Model ID parsing from Yandex API response
+- OAuth → IAM token exchange
+- Header construction (Bearer tokens vs. API keys)
+- Error handling and timeouts
+- Model entry structure validation
+
+### Manual API verification
+
+Before releasing, verify that the Yandex API is accessible and models are being fetched correctly:
+
+```sh
+# OAuth flow
+YANDEX_OAUTH_TOKEN="<token>" YANDEX_FOLDER_ID="<id>" bun run verify.ts
+
+# API key flow
+YANDEX_API_KEY="<key>" YANDEX_FOLDER_ID="<id>" bun run verify.ts
+```
+
+The verification script:
+1. Tests IAM token exchange (OAuth only)
+2. Fetches the list of available models
+3. Tests connectivity to the model API endpoint
+4. Reports any 404 errors or misconfiguration
+
+### Build
+
+```sh
+bun run build
+```
+
+Outputs to `dist/index.js`.

package/bun.lock

@@ -7,6 +7,7 @@
       "devDependencies": {
         "@earendil-works/pi-ai": "latest",
         "@earendil-works/pi-coding-agent": "latest",
+        "@types/bun": "latest",
         "typescript": "^5",
       },
       "peerDependencies": {
@@ -235,6 +236,8 @@
 
     "@tootallnate/quickjs-emscripten": ["@tootallnate/quickjs-emscripten@0.23.0", "", {}, "sha512-C5Mc6rdnsaJDjO3UpGW/CQTHtCKaYlScZTly4JIu97Jxo/odCiH0ITnDXSJPTOrEKk/ycSZ0AOgTmkDtkOsvIA=="],
 
+    "@types/bun": ["@types/bun@1.3.13", "", { "dependencies": { "bun-types": "1.3.13" } }, "sha512-9fqXWk5YIHGGnUau9TEi+qdlTYDAnOj+xLCmSTwXfAIqXr2x4tytJb43E9uCvt09zJURKXwAtkoH4nLQfzeTXw=="],
+
     "@types/mime-types": ["@types/mime-types@2.1.4", "", {}, "sha512-lfU4b34HOri+kAY5UheuFMWPDOI+OPceBSHZKp69gEyTL/mmJ4cnU6Y/rlme3UL3GyOn6Y42hyIEw0/q8sWx5w=="],
 
     "@types/node": ["@types/node@25.6.2", "", { "dependencies": { "undici-types": "~7.19.0" } }, "sha512-sokuT28dxf9JT5Kady1fsXOvI4HVpjZa95NKT5y9PNTIrs2AsobR4GFAA90ZG8M+nxVRLysCXsVj6eGC7Vbrlw=="],
@@ -269,6 +272,8 @@
 
     "buffer-equal-constant-time": ["buffer-equal-constant-time@1.0.1", "", {}, "sha512-zRpUiDwd/xk6ADqPMATG8vc9VPrkck7T07OIx0gnjmJAnHnTVXNQG3vfvWNuiZIkwu9KrKdA1iJKfsfTVxE6NA=="],
 
+    "bun-types": ["bun-types@1.3.13", "", { "dependencies": { "@types/node": "*" } }, "sha512-QXKeHLlOLqQX9LgYaHJfzdBaV21T63HhFJnvuRCcjZiaUDpbs5ED1MgxbMra71CsryN/1dAoXuJJJwIv/2drVA=="],
+
     "chalk": ["chalk@5.6.2", "", {}, "sha512-7NzBL0rN6fMUW+f7A6Io4h40qQlG+xGmtMxfbnH/K7TAtt8JQWVQK+6g0UXKMeVJoyV5EkkNsErQ8pVD3bLHbA=="],
 
     "cli-highlight": ["cli-highlight@2.1.11", "", { "dependencies": { "chalk": "^4.0.0", "highlight.js": "^10.7.1", "mz": "^2.4.0", "parse5": "^5.1.1", "parse5-htmlparser2-tree-adapter": "^6.0.0", "yargs": "^16.0.0" }, "bin": { "highlight": "bin/highlight" } }, "sha512-9KDcoEVwyUXrjcJNvHD0NFc/hiwe/WPVYIleQh2O1N2Zro5gWJZ/K+3DGn8w8P/F6FxOgzyC5bxDyHIgCSPhGg=="],

package/index.test.ts

@@ -0,0 +1,274 @@
+import { describe, it, expect, mock } from "bun:test";
+
+interface MockResponse {
+	ok: boolean;
+	status: number;
+	json: () => Promise<unknown>;
+	text: () => Promise<string>;
+}
+
+describe("pi-yandex-bridge", () => {
+	describe("fetchModelIds", () => {
+		it("should parse Yandex models endpoint response", async () => {
+			const mockResponse: MockResponse = {
+				ok: true,
+				status: 200,
+				json: async () => ({
+					data: [
+						{ id: "gpt://b1g123/yandexgpt" },
+						{ id: "gpt://b1g123/yandexgpt-lite" },
+					],
+				}),
+				text: async () => "{}",
+			};
+
+			global.fetch = mock(async () => mockResponse) as typeof fetch;
+
+			const { fetchModelIds } = await import("./index.ts");
+			const result = await fetchModelIds("b1g123", "Bearer token123");
+
+			expect(result).toEqual([
+				"gpt://b1g123/yandexgpt",
+				"gpt://b1g123/yandexgpt-lite",
+			]);
+		});
+
+		it("should return empty array on API error", async () => {
+			const mockResponse: MockResponse = {
+				ok: false,
+				status: 404,
+				json: async () => ({}),
+				text: async () => "Not Found",
+			};
+
+			global.fetch = mock(async () => mockResponse) as typeof fetch;
+
+			const { fetchModelIds } = await import("./index.ts");
+			const result = await fetchModelIds("b1g123", "Bearer token123");
+
+			expect(result).toEqual([]);
+		});
+
+		it("should send correct headers for OAuth Bearer token", async () => {
+			let capturedHeaders: Record<string, string> = {};
+			const mockResponse: MockResponse = {
+				ok: true,
+				status: 200,
+				json: async () => ({ data: [] }),
+				text: async () => "{}",
+			};
+
+			global.fetch = mock(async (_url: string, opts?: RequestInit) => {
+				if (opts?.headers) {
+					capturedHeaders = opts.headers as Record<string, string>;
+				}
+				return mockResponse;
+			}) as typeof fetch;
+
+			const { fetchModelIds } = await import("./index.ts");
+			await fetchModelIds("b1g123", "Bearer token123");
+
+			expect(capturedHeaders.Authorization).toBe("Bearer token123");
+			expect(capturedHeaders["OpenAI-Project"]).toBe("b1g123");
+		});
+
+		it("should send correct headers for API Key", async () => {
+			let capturedHeaders: Record<string, string> = {};
+			const mockResponse: MockResponse = {
+				ok: true,
+				status: 200,
+				json: async () => ({ data: [] }),
+				text: async () => "{}",
+			};
+
+			global.fetch = mock(async (_url: string, opts?: RequestInit) => {
+				if (opts?.headers) {
+					capturedHeaders = opts.headers as Record<string, string>;
+				}
+				return mockResponse;
+			}) as typeof fetch;
+
+			const { fetchModelIds } = await import("./index.ts");
+			await fetchModelIds("b1g123", "Api-Key apikey123");
+
+			expect(capturedHeaders.Authorization).toBe("Api-Key apikey123");
+			expect(capturedHeaders["OpenAI-Project"]).toBe("b1g123");
+		});
+
+		it("should call correct endpoint", async () => {
+			let capturedUrl: string = "";
+			const mockResponse: MockResponse = {
+				ok: true,
+				status: 200,
+				json: async () => ({ data: [] }),
+				text: async () => "{}",
+			};
+
+			global.fetch = mock(async (url: string) => {
+				capturedUrl = url;
+				return mockResponse;
+			}) as typeof fetch;
+
+			const { fetchModelIds } = await import("./index.ts");
+			await fetchModelIds("b1g123", "Bearer token");
+
+			expect(capturedUrl).toContain("llm.api.cloud.yandex.net");
+			expect(capturedUrl).toContain("/models");
+		});
+	});
+
+	describe("modelEntry", () => {
+		it("should create model entry with correct structure", async () => {
+			const { modelEntry } = await import("./index.ts");
+			const entry = modelEntry("gpt://b1g123/yandexgpt", "b1g123");
+
+			expect(entry.id).toBe("gpt://b1g123/yandexgpt");
+			expect(entry.name).toBe("gpt://b1g123/yandexgpt");
+			expect(entry.api).toBe("openai-responses");
+			expect(entry.provider).toBe("yandex");
+			expect(entry.baseUrl).toContain("ai.api.cloud.yandex.net");
+			expect(entry.headers["OpenAI-Project"]).toBe("b1g123");
+		});
+
+		it("should set correct context window", async () => {
+			const { modelEntry } = await import("./index.ts");
+			const entry = modelEntry("gpt://b1g123/yandexgpt", "b1g123");
+
+			expect(entry.contextWindow).toBe(128000);
+			expect(entry.maxTokens).toBe(8192);
+		});
+
+		it("should disable unsupported features", async () => {
+			const { modelEntry } = await import("./index.ts");
+			const entry = modelEntry("gpt://b1g123/yandexgpt", "b1g123");
+
+			expect(entry.reasoning).toBe(true);
+			expect(entry.compat.supportsReasoningEffort).toBe(false);
+			expect(entry.compat.supportsDeveloperRole).toBe(false);
+		});
+
+		it("should set free cost model", async () => {
+			const { modelEntry } = await import("./index.ts");
+			const entry = modelEntry("gpt://b1g123/yandexgpt", "b1g123");
+
+			expect(entry.cost).toEqual({
+				input: 0,
+				output: 0,
+				cacheRead: 0,
+				cacheWrite: 0,
+			});
+		});
+	});
+
+	describe("exchangeOAuthForIam", () => {
+		it("should exchange OAuth token for IAM token", async () => {
+			const mockResponse: MockResponse = {
+				ok: true,
+				status: 200,
+				json: async () => ({
+					iamToken: "iam_token_xyz",
+					expiresAt: "2026-05-10T15:00:00Z",
+				}),
+				text: async () => "{}",
+			};
+
+			global.fetch = mock(async () => mockResponse) as typeof fetch;
+
+			const { exchangeOAuthForIam } = await import("./index.ts");
+			const result = await exchangeOAuthForIam("oauth_token_abc");
+
+			expect(result.token).toBe("iam_token_xyz");
+			expect(typeof result.expiresAt).toBe("number");
+			expect(result.expiresAt).toBeGreaterThan(0);
+		});
+
+		it("should throw on failed token exchange", async () => {
+			const mockResponse: MockResponse = {
+				ok: false,
+				status: 401,
+				json: async () => ({}),
+				text: async () => "Unauthorized",
+			};
+
+			global.fetch = mock(async () => mockResponse) as typeof fetch;
+
+			const { exchangeOAuthForIam } = await import("./index.ts");
+
+			try {
+				await exchangeOAuthForIam("bad_token");
+				expect.unreachable();
+			} catch (err) {
+				expect(err instanceof Error).toBe(true);
+				expect((err as Error).message).toContain("IAM token exchange failed");
+			}
+		});
+
+		it("should send OAuth token in correct format", async () => {
+			let capturedBody: unknown;
+			const mockResponse: MockResponse = {
+				ok: true,
+				status: 200,
+				json: async () => ({
+					iamToken: "iam_token",
+					expiresAt: "2026-05-10T15:00:00Z",
+				}),
+				text: async () => "{}",
+			};
+
+			global.fetch = mock(async (_url: string, opts?: RequestInit) => {
+				if (opts?.body) {
+					capturedBody = JSON.parse(opts.body as string);
+				}
+				return mockResponse;
+			}) as typeof fetch;
+
+			const { exchangeOAuthForIam } = await import("./index.ts");
+			await exchangeOAuthForIam("my_oauth_token");
+
+			expect(capturedBody).toEqual({
+				yandexPassportOauthToken: "my_oauth_token",
+			});
+		});
+	});
+
+	describe("reasoning mode detection", () => {
+		it("should enable reasoning for YandexGPT models", async () => {
+			const { modelEntry } = await import("./index.ts");
+			const entry = modelEntry("gpt://b1g123/yandexgpt-5-pro/latest", "b1g123");
+			expect(entry.reasoning).toBe(true);
+		});
+
+		it("should enable reasoning for DeepSeek v3.2", async () => {
+			const { modelEntry } = await import("./index.ts");
+			const entry = modelEntry("gpt://b1g123/deepseek-v32/latest", "b1g123");
+			expect(entry.reasoning).toBe(true);
+		});
+
+		it("should enable reasoning for Qwen3 models", async () => {
+			const { modelEntry } = await import("./index.ts");
+			const entry = modelEntry(
+				"gpt://b1g123/qwen3-235b-a22b-fp8/latest",
+				"b1g123",
+			);
+			expect(entry.reasoning).toBe(true);
+		});
+
+		it("should enable reasoning for GPT-OSS models", async () => {
+			const { modelEntry } = await import("./index.ts");
+			const entry = modelEntry("gpt://b1g123/gpt-oss-120b/latest", "b1g123");
+			expect(entry.reasoning).toBe(true);
+		});
+
+		it("should disable reasoning for models without reasoning support", async () => {
+			const { modelEntry } = await import("./index.ts");
+			const entry = modelEntry("gpt://b1g123/aliceai-llm/latest", "b1g123");
+			expect(entry.reasoning).toBe(false);
+		});
+
+		it("should disable reasoning for embedding models", async () => {
+			const { modelEntry } = await import("./index.ts");
+			const entry = modelEntry("emb://b1g123/text-embeddings/latest", "b1g123");
+			expect(entry.reasoning).toBe(false);
+		});
+	});
+});

package/index.ts

@@ -51,23 +51,48 @@ interface IamTokenResponse {
 	expiresAt: string;
 }
 
-// Only applies to yandex gpt:// URIs — leaves all other model IDs untouched.
-function prettyModelName(id: string): string {
-	const match = id.match(/^gpt:\/\/([^/]+)\/(.+?)(?:(\/latest))?$/);
-	if (!match) return id;
-	const [, folderId, slug, hasLatest] = match;
-	const tag = hasLatest ? "/l" : "";
-	return `${slug}{${folderId.slice(-5)}${tag}}`;
+// Model reasoning mode mapping based on Yandex Cloud capabilities
+const REASONING_MODELS = new Set([
+	// YandexGPT models with chain-of-thought reasoning
+	"yandexgpt",
+	"yandexgpt-lite",
+	"yandexgpt-5-lite",
+	"yandexgpt-lite",
+	"yandexgpt-5-pro",
+	// DeepSeek with thinking mode
+	"deepseek-v32",
+	// Qwen models with reasoning support
+	"qwen3-235b-a22b-fp8",
+	"qwen3.5-35b-a3b-fp8",
+	"qwen3.6-35b-a3b",
+	// GPT OSS models with reasoning
+	"gpt-oss-120b",
+	"gpt-oss-20b",
+]);
+
+function getReasoningMode(modelId: string): boolean {
+	// Model ID format: gpt://b1g123/model-name/latest or gpt://b1g123/model-name
+	// Extract model name: it's the last segment if no version, or second-to-last if version exists
+	const parts = modelId.split("/");
+	let modelName = "";
+	if (parts.length >= 4) {
+		// Has version suffix (gpt://b1g123/model-name/latest) → model-name is at parts[3]
+		modelName = parts[3];
+	} else if (parts.length === 3) {
+		// No version suffix (gpt://b1g123/model-name) → model-name is at parts[2]
+		modelName = parts[2];
+	}
+	return REASONING_MODELS.has(modelName);
 }
 
 function modelEntry(id: string, folderId: string) {
 	return {
 		id,
-		name: prettyModelName(id),
+		name: id,
 		api: "openai-responses" as const,
 		provider: "yandex",
 		baseUrl: AI_BASE_URL,
-		reasoning: true,
+		reasoning: getReasoningMode(id),
 		input: ["text"] as ("text" | "image")[],
 		cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
 		contextWindow: 128_000,
@@ -316,6 +341,8 @@ async function runYaLogin(ctx: ExtensionCommandContext) {
 
 // ─── extension entry point ────────────────────────────────────────────────────
 
+// Export for testing
+export { fetchModelIds, modelEntry, exchangeOAuthForIam };
 export default async function (pi: ExtensionAPI) {
 	const apiKey = process.env.YANDEX_API_KEY;
 	const folderId = process.env.YANDEX_FOLDER_ID;

package/package.json

@@ -1,15 +1,19 @@
 {
   "name": "pi-yandex-bridge",
-  "version": "0.2.9",
+  "version": "0.3.1",
   "description": "Pi Coding Agent provider bridge for Yandex Cloud AI (YandexGPT)",
   "main": "./dist/index.js",
   "type": "module",
   "pi": {
-    "extensions": ["./dist/index.js"],
+    "extensions": [
+      "./dist/index.js"
+    ],
     "image": "https://upload.wikimedia.org/wikipedia/commons/5/5b/Yandex_cloud_logo_new.jpg"
   },
   "scripts": {
-    "build": "tsc"
+    "build": "tsc",
+    "test": "bun test",
+    "verify": "bun run verify.ts"
   },
   "keywords": [
     "pi-package",
@@ -28,7 +32,8 @@
   "devDependencies": {
     "@earendil-works/pi-coding-agent": "latest",
     "@earendil-works/pi-ai": "latest",
-    "typescript": "^5"
+    "typescript": "^5",
+    "@types/bun": "latest"
   },
   "license": "MIT",
   "repository": {

package/verify.ts

@@ -0,0 +1,198 @@
+#!/usr/bin/env bun
+/**
+ * Manual API verification script
+ *
+ * Tests Yandex Cloud API connectivity and model availability.
+ * Run before releasing to ensure all endpoints are responding.
+ *
+ * Usage:
+ *   YANDEX_OAUTH_TOKEN=<token> YANDEX_FOLDER_ID=<id> bun run verify.ts
+ *   OR
+ *   YANDEX_API_KEY=<key> YANDEX_FOLDER_ID=<id> bun run verify.ts
+ */
+
+const colors = {
+	reset: "\x1b[0m",
+	green: "\x1b[32m",
+	red: "\x1b[31m",
+	yellow: "\x1b[33m",
+	blue: "\x1b[34m",
+	gray: "\x1b[90m",
+};
+
+const log = {
+	info: (msg: string) => console.log(`${colors.blue}ℹ${colors.reset} ${msg}`),
+	success: (msg: string) => console.log(`${colors.green}✓${colors.reset} ${msg}`),
+	error: (msg: string) => console.log(`${colors.red}✗${colors.reset} ${msg}`),
+	warn: (msg: string) => console.log(`${colors.yellow}⚠${colors.reset} ${msg}`),
+	debug: (msg: string) => console.log(`${colors.gray}${msg}${colors.reset}`),
+};
+
+async function verify() {
+	const oauthToken = process.env.YANDEX_OAUTH_TOKEN;
+	const apiKey = process.env.YANDEX_API_KEY;
+	const folderId = process.env.YANDEX_FOLDER_ID;
+
+	log.info("Yandex Cloud API Verification");
+	console.log();
+
+	// ─── Validate environment ─────────────────────────────────────────────────
+
+	if (!folderId) {
+		log.error("YANDEX_FOLDER_ID env var is required");
+		process.exit(1);
+	}
+
+	if (!oauthToken && !apiKey) {
+		log.error("Either YANDEX_OAUTH_TOKEN or YANDEX_API_KEY env var is required");
+		process.exit(1);
+	}
+
+	log.success(`Using Folder ID: ${folderId}`);
+	const authType = oauthToken ? "OAuth Token" : "API Key";
+	log.success(`Using Auth: ${authType}`);
+	console.log();
+
+	let authHeader = "";
+	let iamToken = "";
+
+	// ─── Step 1: OAuth → IAM token exchange (if using OAuth) ──────────────────
+
+	if (oauthToken) {
+		log.info("Step 1: Exchanging OAuth token for IAM token…");
+		try {
+			const res = await fetch("https://iam.api.cloud.yandex.net/iam/v1/tokens", {
+				method: "POST",
+				headers: { "Content-Type": "application/json" },
+				body: JSON.stringify({ yandexPassportOauthToken: oauthToken }),
+			});
+
+			if (!res.ok) {
+				const text = await res.text().catch(() => res.statusText);
+				log.error(`IAM token exchange failed (${res.status}): ${text}`);
+				process.exit(1);
+			}
+
+			const data = (await res.json()) as {
+				iamToken: string;
+				expiresAt: string;
+			};
+			iamToken = data.iamToken;
+			authHeader = `Bearer ${iamToken}`;
+
+			const expDate = new Date(data.expiresAt).toLocaleString();
+			log.success(`Got IAM token (expires ${expDate})`);
+		} catch (err) {
+			log.error(`OAuth exchange error: ${err instanceof Error ? err.message : err}`);
+			process.exit(1);
+		}
+	} else {
+		authHeader = `Api-Key ${apiKey}`;
+		log.success("Using API Key authentication");
+	}
+
+	console.log();
+
+	// ─── Step 2: Fetch available models ───────────────────────────────────────
+
+	log.info("Step 2: Fetching available models…");
+	let models: Array<{ id: string }> = [];
+
+	try {
+		const res = await fetch("https://llm.api.cloud.yandex.net/v1/models", {
+			headers: {
+				Authorization: authHeader,
+				"OpenAI-Project": folderId,
+			},
+		});
+
+		if (!res.ok) {
+			const text = await res.text().catch(() => res.statusText);
+			log.error(`Models endpoint failed (${res.status}): ${text}`);
+			log.debug("This is the main 404 issue — check folder ID and auth");
+			process.exit(1);
+		}
+
+		const payload = (await res.json()) as { data: Array<{ id: string }> };
+		models = payload.data || [];
+
+		if (models.length === 0) {
+			log.warn("No models returned from API");
+		} else {
+			log.success(`Found ${models.length} model(s)`);
+			models.slice(0, 3).forEach((m) => log.debug(`  • ${m.id}`));
+			if (models.length > 3) log.debug(`  ... and ${models.length - 3} more`);
+		}
+	} catch (err) {
+		log.error(`Models fetch error: ${err instanceof Error ? err.message : err}`);
+		process.exit(1);
+	}
+
+	console.log();
+
+	// ─── Step 3: Test model endpoint (find a working format) ──────────────────
+
+	if (models.length > 0) {
+		log.info("Step 3: Testing model API compatibility…");
+		const testModel = models[0];
+		const baseId = testModel.id;
+
+		// Try different ID formats
+		const formats = [
+			{ name: "full ID", id: baseId },
+			{ name: "without /latest", id: baseId.replace(/\/latest$/, "") },
+			{ name: "just model name", id: baseId.split("/").pop()! },
+		];
+
+		let foundWorking = false;
+
+		for (const fmt of formats) {
+			try {
+				const res = await fetch("https://llm.api.cloud.yandex.net/openai/v1/chat/completions", {
+					method: "POST",
+					headers: {
+						Authorization: authHeader,
+						"OpenAI-Project": folderId,
+						"Content-Type": "application/json",
+					},
+					body: JSON.stringify({
+						model: fmt.id,
+						messages: [{ role: "user", content: "test" }],
+						max_tokens: 10,
+					}),
+				});
+
+				if (res.status === 404) {
+					log.debug(`  ✗ ${fmt.name}: 404 — ${fmt.id}`);
+				} else if (!res.ok) {
+					const text = await res.text().catch(() => res.statusText);
+					log.warn(`  ⚠ ${fmt.name}: ${res.status} — ${text.slice(0, 50)}`);
+				} else {
+					log.success(`  ✓ ${fmt.name}: API responds correctly`);
+					log.debug(`    Model ID format: ${fmt.id}`);
+					foundWorking = true;
+					break;
+				}
+			} catch (err) {
+				log.debug(`  ✗ ${fmt.name}: ${err instanceof Error ? err.message : err}`);
+			}
+		}
+
+		if (!foundWorking) {
+			log.warn("Could not find working model ID format");
+			log.debug(`Test model ID: ${baseId}`);
+		}
+	}
+
+	console.log();
+
+	// ─── Summary ──────────────────────────────────────────────────────────────
+
+	log.success("✓ All checks passed. API is accessible.");
+	log.info(`Ready to release with ${models.length} model(s).`);
+}
+
+verify().catch((err) => {
+	log.error(`Verification failed: ${err instanceof Error ? err.message : err}`);
+	process.exit(1);
+});