@vibesdotdev/client 0.1.1 → 1.0.0-rc.3

package/src/lib/client/internal/node/http2-fetch.node.ts

@@ -1,138 +0,0 @@
-import { getRuntimeEnv } from '@vibesdotdev/runtime';
-import { connect as http2Connect, type ClientHttp2Session } from 'node:http2';
-
-export function createHttp2Fetch(
-	baseUrl: string
-): (input: Parameters<typeof fetch>[0], init?: RequestInit) => Promise<Response> {
-	const sessions = new Map<string, ClientHttp2Session>();
-	const rejectUnauthorized = getRuntimeEnv('REJECT_UNAUTHORIZED') !== 'false';
-
-	return (input: Parameters<typeof fetch>[0], init?: RequestInit): Promise<Response> => {
-		const url =
-			typeof input === 'string'
-				? new URL(input, baseUrl)
-				: input instanceof URL
-					? input
-					: new URL(input.url, baseUrl);
-
-		const method = init?.method?.toUpperCase() || 'GET';
-		const headers = new Headers(init?.headers);
-		const sessionKey = `${url.protocol}//${url.host}`;
-		let session = sessions.get(sessionKey);
-
-		if (!session || session.destroyed || session.closed) {
-			try {
-				session = http2Connect(url.origin, { rejectUnauthorized });
-				sessions.set(sessionKey, session);
-				session.on('close', () => sessions.delete(sessionKey));
-				session.on('error', (error) => {
-					if (sessions.has(sessionKey)) {
-						console.warn('[http2] Session error:', error.message);
-					}
-					sessions.delete(sessionKey);
-				});
-			} catch {
-				return fetch(url.toString(), init);
-			}
-		}
-
-		return new Promise((resolve, reject) => {
-			try {
-				const http2Headers: Record<string, string> = {
-					':method': method,
-					':path': `${url.pathname}${url.search}`,
-					':scheme': url.protocol.replace(':', ''),
-					':authority': url.host
-				};
-				headers.forEach((value, key) => {
-					http2Headers[key.toLowerCase()] = value;
-				});
-				const req = session!.request(http2Headers);
-				let settled = false;
-
-				const abort = () => {
-					if (settled) return;
-					settled = true;
-					try {
-						req.close();
-						req.destroy();
-					} catch {
-						// ignore
-					}
-					const error = new Error('Request aborted');
-					error.name = 'AbortError';
-					reject(error);
-				};
-
-				const signal = init?.signal;
-				if (signal) {
-					if (signal.aborted) {
-						abort();
-						return;
-					}
-					signal.addEventListener('abort', abort, { once: true });
-				}
-
-				const cleanupAbort = () => {
-					if (!signal) return;
-					signal.removeEventListener('abort', abort);
-				};
-
-				if (init?.body) {
-					if (typeof init.body === 'string') {
-						req.write(init.body);
-					} else if (init.body instanceof Buffer) {
-						req.write(init.body);
-					}
-				}
-				req.end();
-
-				const chunks: Buffer[] = [];
-				const responseHeaders = new Headers();
-				let statusCode = 200;
-
-				req.on('response', (headers) => {
-					const statusValue = headers[':status'];
-					statusCode =
-						parseInt(Array.isArray(statusValue) ? statusValue[0] : String(statusValue ?? 200)) ||
-						200;
-					for (const [key, value] of Object.entries(headers)) {
-						if (key.startsWith(':') || value === undefined) continue;
-						if (Array.isArray(value)) value.forEach((v) => responseHeaders.append(key, v));
-						else responseHeaders.set(key, String(value));
-					}
-				});
-
-				req.on('data', (chunk) => {
-					if (typeof chunk === 'string') {
-						chunks.push(Buffer.from(chunk));
-						return;
-					}
-					chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(new Uint8Array(chunk)));
-				});
-
-				req.on('end', () => {
-					if (settled) return;
-					settled = true;
-					cleanupAbort();
-					const body = Buffer.concat(chunks);
-					resolve(
-						new Response(body, {
-							status: statusCode,
-							headers: responseHeaders
-						})
-					);
-				});
-
-				req.on('error', (error) => {
-					if (settled) return;
-					settled = true;
-					cleanupAbort();
-					reject(error);
-				});
-			} catch (error) {
-				reject(error);
-			}
-		});
-	};
-}

package/src/lib/client/internal/request-builder.ts

@@ -1,147 +0,0 @@
-import { ClientError, type AuthConfig, type RequestOptions } from '../types.ts';
-
-export class RequestBuilder {
-	constructor(
-		private baseUrl: string,
-		private auth: AuthConfig,
-		private fetchImpl: typeof fetch,
-		private timeout: number = 30000,
-		private debug: boolean = false
-	) {}
-
-	async request<T = unknown>(options: RequestOptions): Promise<T> {
-		const url = this.buildUrl(options);
-		const headers = await this.buildHeaders(options);
-		const init: RequestInit = {
-			method: options.method,
-			headers,
-			signal: this.createAbortSignal(options.timeout || this.timeout)
-		};
-		if (options.body !== undefined) {
-			if (headers.get('Content-Type')?.includes('application/json'))
-				init.body = JSON.stringify(options.body);
-			else init.body = options.body as NonNullable<RequestInit['body']>;
-		}
-		const shouldLog = this.debug || url.pathname.includes('/auth/');
-		if (shouldLog) {
-			console.info('[Client] Request:', {
-				url: url.toString(),
-				method: options.method,
-				headers: Object.fromEntries(headers.entries()),
-				body: options.body
-			});
-		}
-		try {
-			const response = await this.fetchImpl(url.toString(), init);
-			if (shouldLog) {
-				console.info('[Client] Response:', {
-					status: response.status,
-					statusText: response.statusText,
-					headers: Object.fromEntries(response.headers.entries())
-				});
-			}
-			if (!response.ok) throw await this.createError(response, options);
-			if (response.status === 204 || response.headers.get('Content-Length') === '0')
-				return undefined as T;
-			const contentType = response.headers.get('Content-Type');
-			if (contentType?.includes('application/json')) return (await response.json()) as T;
-			return (await response.text()) as T;
-		} catch (error) {
-			if (this.debug) {
-				console.error('[Client] Request failed:', {
-					url: url.toString(),
-					method: options.method,
-					error: error instanceof Error ? error.message : String(error),
-					errorName: error instanceof Error ? error.name : undefined
-				});
-			}
-			if (error instanceof Error && error.name === 'AbortError') {
-				throw new ClientError('Request timeout', 408, undefined, options);
-			}
-			throw error;
-		}
-	}
-
-	private buildUrl(options: RequestOptions): URL {
-		let path = options.path;
-		if (options.params) {
-			for (const [key, value] of Object.entries(options.params)) {
-				path = path.replace(`{${key}}`, encodeURIComponent(String(value)));
-			}
-		}
-		const url = new URL(path, this.baseUrl);
-		if (options.query) {
-			for (const [key, value] of Object.entries(options.query)) {
-				if (value === undefined) continue;
-				if (Array.isArray(value)) value.forEach((v) => url.searchParams.append(key, String(v)));
-				else url.searchParams.set(key, String(value));
-			}
-		}
-		return url;
-	}
-
-	private async buildHeaders(options: RequestOptions): Promise<Headers> {
-		const headers = new Headers(options.headers);
-		if (!headers.has('Content-Type') && options.body !== undefined)
-			headers.set('Content-Type', 'application/json');
-		if (!headers.has('Accept')) headers.set('Accept', 'application/json');
-		if (this.auth.type !== 'none') {
-			const token = this.auth.credentials || (await this.auth.tokenProvider?.());
-			if (token) {
-				switch (this.auth.type) {
-					case 'apiKey':
-					case 'bearer':
-						headers.set('Authorization', `Bearer ${token}`);
-						break;
-					case 'session':
-						headers.set('Cookie', `session=${token}`);
-						break;
-				}
-			}
-		}
-		return headers;
-	}
-
-	private createAbortSignal(timeout: number): AbortSignal {
-		const controller = new AbortController();
-		setTimeout(() => controller.abort(), timeout);
-		return controller.signal;
-	}
-
-	private async createError(response: Response, request: RequestOptions): Promise<ClientError> {
-		let message = `${response.status} ${response.statusText}`;
-		try {
-			const contentType = response.headers.get('Content-Type');
-			if (contentType?.includes('application/json')) {
-				const error = await response.json();
-				const validationErrors =
-					(error as { issues?: unknown; errors?: unknown }).issues ??
-					(error as { errors?: unknown }).errors;
-				if (Array.isArray(validationErrors) && validationErrors.length > 0) {
-					const fieldErrors = validationErrors
-						.map((issue) => {
-							const rec = issue as { path?: unknown; message?: unknown };
-							const path =
-								Array.isArray(rec.path) && rec.path.length > 0
-									? rec.path.map(String).join('.')
-									: 'unknown';
-							return `  - ${path}: ${typeof rec.message === 'string' ? rec.message : 'Invalid'}`;
-						})
-						.join('\n');
-					message = `Validation failed:\n${fieldErrors}`;
-				} else if (typeof (error as { message?: unknown }).message === 'string') {
-					message = (error as { message: string }).message;
-				} else if ((error as { error?: unknown }).error !== undefined) {
-					const e = (error as { error: unknown }).error;
-					message = typeof e === 'string' ? e : JSON.stringify(e);
-				}
-			} else {
-				const text = await response.text();
-				if (text) message = text;
-			}
-		} catch {
-			// ignore parsing errors
-		}
-		return new ClientError(message, response.status, response, request);
-	}
-}

package/src/lib/client/internal/sse-stream.ts

@@ -1,130 +0,0 @@
-import { type AuthConfig, type RequestOptions, ClientError } from '../types.ts';
-
-export interface SSEEvent<T = unknown> {
-	event?: string;
-	data: T;
-	id?: string;
-	retry?: number;
-}
-
-export type SSEStreamOptions = {
-	method?: string;
-	params?: Record<string, string | number | boolean>;
-	query?: Record<string, string | number | boolean | string[] | undefined>;
-	body?: unknown;
-	headers?: Record<string, string>;
-	timeout?: number;
-};
-
-export async function* streamSSE<T = unknown>(args: {
-	baseUrl: string;
-	auth: AuthConfig;
-	fetchImpl: typeof fetch;
-	path: string;
-	options?: SSEStreamOptions;
-}): AsyncIterableIterator<SSEEvent<T>> {
-	const options = args.options ?? {};
-	let url = `${args.baseUrl}${args.path}`;
-	if (options.params) {
-		for (const [key, value] of Object.entries(options.params)) {
-			url = url.replace(`:${key}`, String(value));
-			url = url.replace(`{${key}}`, String(value));
-		}
-	}
-	if (options.query) {
-		const searchParams = new URLSearchParams();
-		for (const [key, value] of Object.entries(options.query)) {
-			if (value === undefined || value === null) continue;
-			if (Array.isArray(value)) value.forEach((v) => searchParams.append(key, String(v)));
-			else searchParams.append(key, String(value));
-		}
-		const queryString = searchParams.toString();
-		if (queryString) url += `?${queryString}`;
-	}
-	const headers: Record<string, string> = { Accept: 'text/event-stream', ...options.headers };
-	if (!('Content-Type' in headers)) headers['Content-Type'] = 'application/json';
-	if (args.auth.type === 'apiKey' && args.auth.credentials) {
-		headers['X-API-Key'] = args.auth.credentials;
-	} else if (args.auth.type === 'bearer') {
-		const token = args.auth.tokenProvider ? await args.auth.tokenProvider() : args.auth.credentials;
-		if (token) headers.Authorization = `Bearer ${token}`;
-	}
-	const requestOptions: RequestOptions = {
-		method: options.method || 'POST',
-		path: args.path,
-		params: options.params,
-		query: options.query,
-		body: options.body,
-		headers: options.headers,
-		timeout: options.timeout
-	};
-	const requestInit: RequestInit = { method: requestOptions.method, headers };
-	if (requestOptions.timeout) {
-		const controller = new AbortController();
-		setTimeout(() => controller.abort(), requestOptions.timeout);
-		requestInit.signal = controller.signal;
-	}
-	if (options.body !== undefined) requestInit.body = JSON.stringify(options.body);
-	const response = await args.fetchImpl(url, requestInit);
-	if (!response.ok) {
-		throw new ClientError(
-			`SSE stream failed: ${response.statusText}`,
-			response.status,
-			response,
-			requestOptions
-		);
-	}
-	if (!response.body) {
-		throw new ClientError(
-			'No response body for SSE stream',
-			response.status,
-			response,
-			requestOptions
-		);
-	}
-	const reader = response.body.getReader();
-	const decoder = new TextDecoder();
-	let buffer = '';
-	try {
-		while (true) {
-			const { done, value } = await reader.read();
-			if (done) break;
-			buffer += decoder.decode(value, { stream: true });
-			const lines = buffer.split('\n');
-			buffer = lines.pop() || '';
-			let currentEvent: Partial<SSEEvent<T>> = {};
-			for (const line of lines) {
-				if (line.trim() === '') {
-					if (currentEvent.data !== undefined) {
-						yield currentEvent as SSEEvent<T>;
-						currentEvent = {};
-					}
-					continue;
-				}
-				if (line.startsWith('event:')) {
-					currentEvent.event = line.slice(6).trim();
-					continue;
-				}
-				if (line.startsWith('data:')) {
-					const dataStr = line.slice(5).trim();
-					if (dataStr === '[DONE]') return;
-					try {
-						currentEvent.data = JSON.parse(dataStr) as T;
-					} catch {
-						currentEvent.data = dataStr as T;
-					}
-					continue;
-				}
-				if (line.startsWith('id:')) {
-					currentEvent.id = line.slice(3).trim();
-					continue;
-				}
-				if (line.startsWith('retry:')) {
-					currentEvent.retry = parseInt(line.slice(6).trim());
-				}
-			}
-		}
-	} finally {
-		reader.releaseLock();
-	}
-}

package/src/lib/client/internal/vibes-client.ts

@@ -1,167 +0,0 @@
-import type { AuthConfig, ClientConfig, ClientHooks, RequestOptions } from '../types.ts';
-import { APIGenerator, type OpenAPISpec } from './generator.ts';
-import { getRuntimeEnv } from '@vibesdotdev/runtime';
-import { RequestBuilder } from './request-builder.ts';
-import { streamSSE, type SSEEvent, type SSEStreamOptions } from './sse-stream.ts';
-import { createHookedFetch } from './wrap-fetch.ts';
-
-interface ResolvedClientConfig {
-	baseUrl: string;
-	auth: AuthConfig;
-	fetch: typeof fetch;
-	hooks: ClientHooks;
-	timeout: number;
-	debug: boolean;
-}
-
-export class VibesClient {
-	private config: ResolvedClientConfig;
-	private requestBuilder: RequestBuilder;
-	private apiGenerator: APIGenerator;
-	private apis: Record<string, unknown> = {};
-	private specPromise: Promise<OpenAPISpec> | null = null;
-
-	constructor(config: ClientConfig = {}) {
-		const baseUrl =
-			config.baseUrl ||
-			getRuntimeEnv('VIBES_API_URL') ||
-			'http://localhost:5173';
-		const fetchImpl = config.fetch || globalThis.fetch?.bind(globalThis);
-		if (!fetchImpl)
-			throw new Error('Fetch is not available. Please provide a fetch implementation.');
-		const hooks = config.hooks || {};
-		this.config = {
-			baseUrl,
-			auth: config.auth || { type: 'none' },
-			fetch: fetchImpl as typeof fetch,
-			hooks,
-			timeout: config.timeout || 30000,
-			debug: config.debug || false
-		};
-		const hookedFetch = createHookedFetch({
-			fetchImpl: this.config.fetch,
-			hooks: this.config.hooks
-		});
-		this.requestBuilder = new RequestBuilder(
-			this.config.baseUrl,
-			this.config.auth,
-			hookedFetch as typeof fetch,
-			this.config.timeout,
-			this.config.debug
-		);
-		this.apiGenerator = new APIGenerator(this.requestBuilder);
-	}
-
-	private async initialize(): Promise<void> {
-		try {
-			const spec = await this.getOpenAPISpec();
-			this.buildAPIs(spec);
-		} catch (error) {
-			const shouldWarn =
-				this.config.debug ||
-				(typeof process !== 'undefined' && process.env?.VIBES_CLIENT_WARN_OAS === 'true');
-			if (shouldWarn) {
-				console.warn('Failed to load OpenAPI spec, client will have limited functionality:', error);
-			}
-		}
-	}
-
-	getOpenAPISpec(): Promise<OpenAPISpec> {
-		if (!this.specPromise) this.specPromise = this.fetchOpenAPISpec();
-		return this.specPromise;
-	}
-
-	private async fetchOpenAPISpec(): Promise<OpenAPISpec> {
-		const response = await this.config.fetch(`${this.config.baseUrl}/api/docs/openapi.json`);
-		if (!response.ok) throw new Error(`Failed to fetch OpenAPI spec: ${response.statusText}`);
-		return response.json() as Promise<OpenAPISpec>;
-	}
-
-	private buildAPIs(spec: OpenAPISpec): void {
-		const apis = this.apiGenerator.generateAPIs(spec);
-		for (const [name, api] of Object.entries(apis)) {
-			this.apis[name] = api;
-			Object.defineProperty(this, name, {
-				get: () => this.apis[name],
-				enumerable: true,
-				configurable: true
-			});
-		}
-	}
-
-	request<T = unknown>(
-		path: string,
-		options: {
-			method?: string;
-			params?: Record<string, string | number | boolean>;
-			query?: Record<string, string | number | boolean | string[] | undefined>;
-			body?: unknown;
-			headers?: Record<string, string>;
-			timeout?: number;
-		} = {}
-	): Promise<T> {
-		return this.requestBuilder.request({
-			path,
-			method: options.method || 'GET',
-			params: options.params,
-			query: options.query,
-			body: options.body,
-			headers: options.headers,
-			timeout: options.timeout
-		});
-	}
-
-	setAuth(auth: AuthConfig): void {
-		this.config.auth = auth;
-		const hookedFetch = createHookedFetch({
-			fetchImpl: this.config.fetch,
-			hooks: this.config.hooks
-		});
-		this.requestBuilder = new RequestBuilder(
-			this.config.baseUrl,
-			auth,
-			hookedFetch as typeof fetch,
-			this.config.timeout,
-			this.config.debug
-		);
-		this.apiGenerator = new APIGenerator(this.requestBuilder);
-		if (this.specPromise) this.specPromise.then((spec) => this.buildAPIs(spec));
-	}
-
-	getResources(): string[] {
-		return Object.keys(this.apis);
-	}
-
-	hasResource(name: string): boolean {
-		return name in this.apis;
-	}
-
-	get<T = unknown>(endpoint: string, options?: RequestOptions): Promise<T> {
-		return this.request<T>(endpoint, { ...options, method: 'GET' });
-	}
-
-	post<T = unknown>(endpoint: string, body?: unknown, options?: RequestOptions): Promise<T> {
-		return this.request<T>(endpoint, { ...options, method: 'POST', body });
-	}
-
-	put<T = unknown>(endpoint: string, body?: unknown, options?: RequestOptions): Promise<T> {
-		return this.request<T>(endpoint, { ...options, method: 'PUT', body });
-	}
-
-	delete<T = unknown>(endpoint: string, options?: RequestOptions): Promise<T> {
-		return this.request<T>(endpoint, { ...options, method: 'DELETE' });
-	}
-
-	async *stream<T = unknown>(
-		path: string,
-		options: SSEStreamOptions = {}
-	): AsyncIterableIterator<SSEEvent<T>> {
-		yield* streamSSE<T>({
-			baseUrl: this.config.baseUrl,
-			auth: this.config.auth,
-			fetchImpl: this.config.fetch,
-			path,
-			options
-		});
-	}
-}

package/src/lib/client/internal/wrap-fetch.ts

@@ -1,59 +0,0 @@
-import { ClientError, type ClientHooks } from '../types.ts';
-
-export function createHookedFetch(args: {
-	fetchImpl: typeof fetch;
-	hooks: ClientHooks;
-}): (input: Parameters<typeof fetch>[0], init?: RequestInit) => Promise<Response> {
-	return async (input: Parameters<typeof fetch>[0], init?: RequestInit) => {
-		if (!args.hooks.beforeRequest) {
-			let response: Response;
-			try {
-				response = await args.fetchImpl(input, init);
-			} catch (error) {
-				if (args.hooks.onError) {
-					await args.hooks.onError(
-						new ClientError(
-							error instanceof Error ? error.message : 'Network error',
-							0,
-							undefined,
-							undefined
-						)
-					);
-				}
-				throw error;
-			}
-			if (args.hooks.afterResponse) response = await args.hooks.afterResponse(response);
-			return response;
-		}
-		const requestInput = input instanceof URL
-			? new Request(input.href, init)
-			: typeof input === 'string'
-				? new Request(input, init)
-				: new Request(input, init);
-		const modifiedRequest = await args.hooks.beforeRequest(requestInput);
-		const modifiedInit: RequestInit = {
-			...init,
-			method: modifiedRequest.method,
-			headers: Object.fromEntries(modifiedRequest.headers.entries()),
-			...(modifiedRequest.body !== requestInput.body && { body: modifiedRequest.body })
-		};
-		let response: Response;
-		try {
-			response = await args.fetchImpl(modifiedRequest.url, modifiedInit);
-		} catch (error) {
-			if (args.hooks.onError) {
-				await args.hooks.onError(
-					new ClientError(
-						error instanceof Error ? error.message : 'Network error',
-						0,
-						undefined,
-						undefined
-					)
-				);
-			}
-			throw error;
-		}
-		if (args.hooks.afterResponse) response = await args.hooks.afterResponse(response);
-		return response;
-	};
-}

package/src/lib/client/node.ts

@@ -1,36 +0,0 @@
-import { getRuntimeEnv } from '@vibesdotdev/runtime';
-import type { ClientConfig } from './types.ts';
-import { VibesClient } from './internal/vibes-client.ts';
-
-export { createHttp2Fetch } from './internal/node/http2-fetch.node.ts';
-
-async function resolveNodeFetch(baseUrl: string): Promise<typeof globalThis.fetch> {
-	const isHttps = baseUrl.startsWith('https://');
-	const isLocal =
-		baseUrl.includes('.local') || baseUrl.includes('localhost') || baseUrl.includes('127.0.0.1');
-	if (isHttps && isLocal) {
-		try {
-			if (!getRuntimeEnv('REJECT_UNAUTHORIZED')) {
-				globalThis.process?.['env'] && (globalThis.process.env.REJECT_UNAUTHORIZED = 'false');
-			}
-			const { createHttp2Fetch } = await import('./internal/node/http2-fetch.node.js');
-			return createHttp2Fetch(baseUrl) as unknown as typeof globalThis.fetch;
-		} catch {
-			// Fallback to regular fetch if h2 module unavailable
-		}
-	}
-	return globalThis.fetch;
-}
-
-export async function createCLIClient(config?: Partial<ClientConfig>): Promise<VibesClient> {
-	const baseUrl = config?.baseUrl || getRuntimeEnv('VIBES_API_URL') || 'http://localhost:5173';
-	const fetchImpl = config?.fetch || (await resolveNodeFetch(baseUrl));
-	const clientConfig: ClientConfig = {
-		baseUrl,
-		auth: config?.auth || { type: 'none' },
-		fetch: fetchImpl,
-		debug: getRuntimeEnv('VIBES_DEBUG') === 'true',
-		...config
-	};
-	return new VibesClient(clientConfig);
-}