@crustjs/openapi 0.0.0 → 0.1.0

package/README.md

@@ -1,3 +1,15 @@
 # @crustjs/openapi
 
-This `0.0.0` version is an empty placeholder, published once so the package can use npm trusted publishing. Do not install it. The first real release will be `0.1.0`. See https://crustjs.com.
+Call a CLI's HTTP API and browse its OpenAPI spec from an api command
+
+`apiCommand({ spec, baseUrl, auth })` adds `<cli> api`, a `gh api`-style escape hatch: `--list` and `--spec` read the bundled OpenAPI document offline, and `api <path>` sends an authenticated request. It also provides the `apiClient` Context, so your own commands share the same base URL and auth.
+
+## Install
+
+```sh
+npm install @crustjs/openapi
+```
+
+## Documentation
+
+Full docs: [crustjs.com/docs/modules/openapi](https://crustjs.com/docs/modules/openapi)

package/dist/index.d.ts

@@ -0,0 +1,128 @@
+import { CommandDefinition, CommandShape, ContextFactory, ContextInstance, ContextSetup, ExtensionFactory } from "@crustjs/core";
+interface ApiClientOptions {
+  /** URL request paths resolve against, e.g. `https://api.example.com/v1`. */
+  readonly baseUrl: string;
+  /**
+   * Headers added to requests to the base URL's origin, e.g. an `Authorization` header, or any
+   * default header such as `User-Agent` or an API-version header. All of them are treated as
+   * credentials: they are never sent off the base URL's origin.
+   * Called at most once per invocation, on the first request that sends credentials: never
+   * for a command that only reads the Context, nor for requests with `auth: false`.
+   */
+  readonly auth?: (input: ContextSetup) => Readonly<Record<string, string>> | undefined | Promise<Readonly<Record<string, string>> | undefined>;
+}
+/** The `api` Context value: `fetch()` bound to the API's base URL and auth. */
+interface ApiClient {
+  readonly baseUrl: string;
+  /**
+   * `fetch()` for `path` below {@link ApiClient.baseUrl} (an absolute URL is used as is, but
+   * must be on the base URL's origin: otherwise it rejects with a `TypeError` before any request),
+   * with the `auth` headers the request does not set itself, and the invocation's signal
+   * unless `init.signal` is given. Redirects are followed here
+   * (up to 20 per request, http: and https: only); one to another origin than the base URL's
+   * continues without `Authorization`, `Cookie`, `Proxy-Authorization`, or any header named like an `auth` header.
+   * With `auth: false` (e.g. a public operation), neither the request nor its redirects
+   * call `auth` or carry its headers.
+   */
+  fetch(path: string, init?: RequestInit & {
+    readonly auth?: false;
+  }): Promise<Response>;
+}
+/**
+ * The shared API client Context. {@link apiCommand} provides it, so app commands
+ * declare `.use(apiClient)` and call `(await ctx.api).fetch("/users")`.
+ */
+export declare const apiClient: ContextFactory<"api", ApiClientOptions, ApiClient>;
+/**
+ * An OpenAPI document; only `paths` and local `$ref` targets are read. Keys of `paths`
+ * not starting with `/`, such as `x-*` extensions, are skipped.
+ */
+interface OpenApiSpec {
+  readonly paths?: Readonly<Record<string, unknown>>;
+  readonly [key: string]: unknown;
+}
+/** A request for {@link ApiClient.fetch}; without `init`, the previous request's is reused. */
+interface ApiRequest {
+  readonly path: string;
+  readonly init?: RequestInit;
+}
+interface ApiCommandOptions extends ApiClientOptions {
+  /**
+   * The OpenAPI document, e.g. an imported JSON file bundled with the CLI and read offline;
+   * or a loader for it, called with the invocation's signal only when `api --list` or
+   * `api --spec` runs, e.g. a lazy `import()` of the JSON file that keeps it out of startup.
+   */
+  readonly spec: OpenApiSpec | ((input: {
+    signal: AbortSignal;
+  }) => OpenApiSpec | Promise<OpenApiSpec>);
+  /**
+   * The next page's request for `--paginate`, or `undefined` after the last page.
+   * Receives a copy of each successful response, so it may read the body. The next page
+   * must be http(s); off the base URL's origin it is requested without credential headers.
+   * Returning the previous request again (same URL and method, `init` reused) fails instead of looping.
+   */
+  readonly paginate?: (response: Response) => ApiRequest | undefined | Promise<ApiRequest | undefined>;
+}
+/** A non-2xx response to `api <path>`; its body was already printed to stdout. */
+export declare class ApiResponseError extends Error {
+  override name: string;
+  /** The HTTP status code. */
+  readonly status: number;
+  constructor(status: number, message: string);
+}
+declare const pathArg: {
+  readonly name: "path";
+  readonly type: "string";
+  readonly description: "Request path below the API base URL, e.g. /users";
+};
+declare const apiFlags: {
+  readonly list: {
+    readonly type: "boolean";
+    readonly noNegate: true;
+    readonly description: "List the API's operations";
+  };
+  readonly spec: {
+    readonly type: "string";
+    readonly description: "Print the OpenAPI definition of an operationId or path";
+  };
+  readonly method: {
+    readonly type: "string";
+    readonly short: "X";
+    readonly description: "HTTP method; default GET, or POST with fields or a body";
+  };
+  readonly header: {
+    readonly type: "string";
+    readonly short: "H";
+    readonly multiple: true;
+    readonly description: "Request header, 'Key: Value'";
+  };
+  readonly field: {
+    readonly type: "string";
+    readonly short: "F";
+    readonly multiple: true;
+    readonly description: "key=value; true, false, null, and numbers are sent as JSON";
+  };
+  readonly body: {
+    readonly type: "string";
+    readonly description: "Request body: inline, @file, or - for stdin";
+  };
+  readonly paginate: {
+    readonly type: "boolean";
+    readonly noNegate: true;
+    readonly description: "Fetch every page, printing each response body as one JSON line";
+  };
+};
+/** The contributed `api` command, spelled out because the exported factory needs a declared type. */
+type ApiCommandDefinition = CommandDefinition<"api", readonly [], CommandShape<readonly [typeof pathArg], typeof apiFlags, {}, void, {}, undefined>, {
+  api: ApiClient;
+}>;
+/**
+ * Provides the {@link apiClient} Context and contributes `api`: `api --list` and
+ * `api --spec <operationId|path>` read the spec (calling its loader, if any); `api <path>` sends
+ * a request through the client, prints the response body to stdout, and fails with
+ * {@link ApiResponseError} on a non-2xx status.
+ */
+export declare const apiCommand: ExtensionFactory<[options: ApiCommandOptions], {
+  api: ApiClient;
+}, readonly [ContextInstance<"api", ApiClient, {}, {}>], {}, readonly [ApiCommandDefinition], never, {}>;
+export type { ApiClient, ApiClientOptions, ApiCommandOptions, ApiRequest, OpenApiSpec };

package/dist/index.js

@@ -0,0 +1,427 @@
+import { CrustError, defineCommand, defineContext, defineExtension, defineExtensionId } from "@crustjs/core";
+// src/client.ts
+/** `path` joined below `baseUrl`, keeping the base's own path; absolute URLs pass through. */
+function resolveUrl(baseUrl, path) {
+	return URL.canParse(path) ? new URL(path) : new URL(`${baseUrl.replace(/\/+$/, "")}/${path.replace(/^\/+/, "")}`);
+}
+/**
+* `path` resolved like {@link ApiClient.fetch} does for a first request, which must stay on
+* `baseUrl`'s origin, so credentials set for the API never go to a host the caller named;
+* only redirects and next pages may leave it. Throws a `TypeError` for any other origin.
+*/
+function baseOriginUrl(baseUrl, path) {
+	const url = resolveUrl(baseUrl, path);
+	const { origin } = new URL(baseUrl);
+	if (url.origin !== origin) throw new TypeError(`Cannot request ${url.href}: only URLs on ${origin} are allowed`);
+	return url;
+}
+const REDIRECT_STATUSES = /* @__PURE__ */ new Set([
+	301,
+	302,
+	303,
+	307,
+	308
+]);
+const MAX_REDIRECTS = 20;
+const BODY_HEADERS = [
+	"content-encoding",
+	"content-language",
+	"content-location",
+	"content-type"
+];
+/** `response` reporting `redirected`, as `fetch()` does after following a redirect, on its clones too. */
+function markRedirected(response) {
+	const clone = response.clone.bind(response);
+	return Object.defineProperties(response, {
+		redirected: { value: true },
+		clone: { value: () => markRedirected(clone()) }
+	});
+}
+const nextPageFetchers = /* @__PURE__ */ new WeakMap();
+/**
+* `client.fetch()` for a next page a response named: like a redirect target, it must be
+* http(s) and gets no credential headers off the base URL's origin, even ones the request set.
+*/
+function fetchNextPage(client, path, init) {
+	const fetchNext = nextPageFetchers.get(client);
+	if (fetchNext === void 0) throw new TypeError("fetchNextPage: not an apiClient Context value");
+	return fetchNext(path, init);
+}
+/**
+* The shared API client Context. {@link apiCommand} provides it, so app commands
+* declare `.use(apiClient)` and call `(await ctx.api).fetch("/users")`.
+*/
+const apiClient = /* @__PURE__ */ defineContext("api").setup(async (input, options) => {
+	const origin = new URL(options.baseUrl).origin;
+	const credentialHeaders = [
+		"authorization",
+		"cookie",
+		"proxy-authorization"
+	];
+	let authHeaders;
+	async function loadAuthHeaders() {
+		const headers = new Headers(await options.auth?.(input));
+		credentialHeaders.push(...headers.keys());
+		return headers;
+	}
+	const firstHop = (url, { auth, ...init } = {}) => ({
+		url,
+		init: {
+			...init,
+			headers: new Headers(init.headers),
+			signal: init.signal ?? input.signal
+		},
+		auth: auth !== false,
+		redirects: 0
+	});
+	/**
+	* The request for `target` after `from`, for a redirect with `status` or, without one,
+	* a next page. Every move to a URL a response named goes through here, so the protocol,
+	* redirect limit, and credential rules cannot be bypassed.
+	*/
+	function step(from, target, status) {
+		from.init.signal?.throwIfAborted();
+		if (target.protocol !== "http:" && target.protocol !== "https:") throw new TypeError(`Cannot request ${target.href}: only http: and https: URLs`);
+		const headers = new Headers(from.init.headers);
+		let { method = "GET", body } = from.init;
+		if (status !== void 0) {
+			if (from.redirects === MAX_REDIRECTS) throw new TypeError(`fetch ${from.url.href}: too many redirects`);
+			const upper = method.toUpperCase();
+			if (status === 303 ? upper !== "GET" && upper !== "HEAD" : status <= 302 && upper === "POST") {
+				method = "GET";
+				body = null;
+				for (const name of BODY_HEADERS) headers.delete(name);
+			}
+		}
+		if (target.origin !== origin) for (const name of credentialHeaders) headers.delete(name);
+		const redirects = from.redirects + (status === void 0 ? 0 : 1);
+		return {
+			...from,
+			url: target,
+			init: {
+				...from.init,
+				method,
+				body,
+				headers
+			},
+			redirects
+		};
+	}
+	async function send(hop) {
+		const redirect = hop.init.redirect ?? "follow";
+		for (;;) {
+			const headers = new Headers(hop.init.headers);
+			if (hop.auth && hop.url.origin === origin) {
+				for (const [name, value] of await (authHeaders ??= loadAuthHeaders())) if (!headers.has(name)) headers.set(name, value);
+			}
+			const response = await fetch(hop.url, {
+				...hop.init,
+				headers,
+				redirect: redirect === "follow" ? "manual" : redirect
+			});
+			const location = response.headers.get("location");
+			if (redirect !== "follow" || !REDIRECT_STATUSES.has(response.status) || location === null) return hop.redirects > 0 ? markRedirected(response) : response;
+			await response.body?.cancel();
+			hop = step(hop, new URL(location, hop.url), response.status);
+		}
+	}
+	const client = {
+		baseUrl: options.baseUrl,
+		fetch: async (path, init) => send(firstHop(baseOriginUrl(options.baseUrl, path), init))
+	};
+	nextPageFetchers.set(client, (path, init) => {
+		const target = resolveUrl(options.baseUrl, path);
+		return send(step(firstHop(target, init), target));
+	});
+	return client;
+});
+// src/api-command.ts
+const API = /* @__PURE__ */ defineExtensionId("crust:openapi");
+/** A non-2xx response to `api <path>`; its body was already printed to stdout. */
+var ApiResponseError = class extends Error {
+	name = "ApiResponseError";
+	/** The HTTP status code. */
+	status;
+	constructor(status, message) {
+		super(message);
+		this.status = status;
+	}
+};
+const METHODS = [
+	"get",
+	"put",
+	"post",
+	"delete",
+	"options",
+	"head",
+	"patch",
+	"trace"
+];
+/**
+* The value a local `$ref`'s JSON Pointer fragment (`#/...`, URI-encoded or not) points to
+* in `spec`, or `undefined`, also for other fragments such as `#anchor`.
+*/
+function refTarget(spec, ref) {
+	let pointer;
+	try {
+		pointer = decodeURIComponent(ref.slice(1));
+	} catch {
+		return;
+	}
+	if (pointer !== "" && !pointer.startsWith("/")) return void 0;
+	let target = spec;
+	for (const token of pointer.split("/").slice(1)) {
+		const key = token.replaceAll("~1", "/").replaceAll("~0", "~");
+		target = typeof target === "object" && target !== null && Object.hasOwn(target, key) ? target[key] : void 0;
+	}
+	return target;
+}
+/** A Path Item with its own local `$ref`s (e.g. to `components.pathItems`) followed; sibling keys win. */
+function pathItem(spec, item) {
+	let current = item;
+	const seen = /* @__PURE__ */ new Set();
+	for (let ref = current.$ref; typeof ref === "string" && ref.startsWith("#") && !seen.has(ref); ref = current.$ref) {
+		seen.add(ref);
+		const target = refTarget(spec, ref);
+		if (typeof target !== "object" || target === null || Array.isArray(target)) break;
+		const { $ref: _ref, ...siblings } = current;
+		current = {
+			...target,
+			...siblings
+		};
+	}
+	return current;
+}
+function operations(spec) {
+	return Object.entries(spec.paths ?? {}).flatMap(([path, item]) => {
+		if (!path.startsWith("/") || typeof item !== "object" || item === null) return [];
+		const resolved = pathItem(spec, item);
+		return METHODS.flatMap((method) => {
+			const operation = resolved[method];
+			return typeof operation === "object" && operation !== null ? [{
+				method,
+				path,
+				operation
+			}] : [];
+		});
+	});
+}
+/** `spec`, or what its loader returns; a failure other than cancellation becomes a plain `Error`. */
+async function loadSpec(spec, signal) {
+	if (typeof spec !== "function") return spec;
+	let loaded;
+	try {
+		loaded = await spec({ signal });
+	} catch (cause) {
+		if (signal.aborted && cause === signal.reason || cause instanceof Error && cause.name === "AbortError") throw cause;
+		const reason = cause instanceof Error ? cause.message : String(cause);
+		throw new Error(`api: cannot load the OpenAPI document (${reason})`, { cause });
+	}
+	const tag = Object.prototype.toString.call(loaded).slice(8, -1);
+	const prototype = tag === "Object" ? Object.getPrototypeOf(loaded) : void 0;
+	if (tag !== "Object" || prototype !== Object.prototype && prototype !== null) {
+		const kind = tag === "Object" ? "class instance" : tag.toLowerCase();
+		throw new Error(`api: cannot load the OpenAPI document (expected a plain object, got ${kind})`);
+	}
+	return loaded;
+}
+/** One line per operation: `METHOD path operationId summary`, omitting what the spec lacks. */
+function listOperations(spec) {
+	return operations(spec).map(({ method, path, operation }) => {
+		const { operationId, summary } = operation;
+		return [
+			method.toUpperCase(),
+			path,
+			operationId,
+			summary
+		].filter((part) => typeof part === "string" && part !== "").join(" ");
+	});
+}
+/** Follows local `$ref`s (`#/...`), keeping sibling keys; a `$ref` back into its own chain stays as is. */
+function resolveRefs(value, spec, chain) {
+	if (Array.isArray(value)) return value.map((item) => resolveRefs(item, spec, chain));
+	if (typeof value !== "object" || value === null) return value;
+	const { $ref, ...siblings } = value;
+	if (typeof $ref === "string" && $ref.startsWith("#") && !chain.includes($ref)) {
+		const target = refTarget(spec, $ref);
+		if (target !== void 0) {
+			const resolved = resolveRefs(target, spec, [...chain, $ref]);
+			return typeof resolved === "object" && resolved !== null && !Array.isArray(resolved) ? {
+				...resolved,
+				...resolveRefs(siblings, spec, chain)
+			} : resolved;
+		}
+	}
+	return Object.fromEntries(Object.entries(value).map(([key, item]) => [key, resolveRefs(item, spec, chain)]));
+}
+/**
+* The path item for a spec path, or the operation with that `operationId`, with
+* local `$ref`s resolved.
+*/
+function specFor(spec, target) {
+	const paths = spec.paths ?? {};
+	const found = target.startsWith("/") && Object.hasOwn(paths, target) ? paths[target] : operations(spec).find(({ operation }) => operation.operationId === target)?.operation;
+	if (found === void 0) throw new Error(`No operation or path "${target}" in the OpenAPI spec`);
+	return resolveRefs(found, spec, []);
+}
+const JSON_NUMBER = /^-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?$/;
+/** `key=value`; `true`, `false`, `null`, and JSON numbers become JSON values, like `gh api -F`. */
+function parseField(field) {
+	const at = field.indexOf("=");
+	if (at <= 0) throw new CrustError("PARSE", "Invalid -F value: expected key=value.", { flag: "field" });
+	const value = field.slice(at + 1);
+	const literals = {
+		true: true,
+		false: false,
+		null: null
+	};
+	if (Object.hasOwn(literals, value)) return [field.slice(0, at), literals[value]];
+	if (!JSON_NUMBER.test(value)) return [field.slice(0, at), value];
+	const number = Number(value);
+	if (!Number.isFinite(number)) throw new CrustError("PARSE", `Invalid -F value for "${field.slice(0, at)}": the number is out of range.`, { flag: "field" });
+	return [field.slice(0, at), number];
+}
+function parseHeader(header) {
+	const at = header.indexOf(":");
+	if (at <= 0) throw new CrustError("PARSE", "Invalid -H value: expected \"Name: value\".", { flag: "header" });
+	const entry = [header.slice(0, at).trim(), header.slice(at + 1).trim()];
+	try {
+		new Headers().append(...entry);
+	} catch {
+		throw new CrustError("PARSE", "Invalid -H value: the header name or value has characters HTTP does not allow.", { flag: "header" });
+	}
+	return entry;
+}
+/** Inline text, `@path` (relative to the working directory), or `-` (all of stdin). */
+async function readBody(value, signal) {
+	if (value !== "-" && !value.startsWith("@")) return value;
+	try {
+		return value === "-" ? await (await import("@crustjs/utils/process")).readStdin(signal) : process.getBuiltinModule("node:fs").readFileSync(value.slice(1), "utf8");
+	} catch (cause) {
+		if (signal.aborted && cause === signal.reason) throw cause;
+		const name = value === "-" ? "stdin" : `"${value.slice(1)}"`;
+		const reason = cause instanceof Error ? ` (${cause.message})` : "";
+		throw new CrustError("PARSE", `--body: cannot read ${name}${reason}`, { flag: "body" }).withCause(cause);
+	}
+}
+const pathArg = {
+	name: "path",
+	type: "string",
+	description: "Request path below the API base URL, e.g. /users"
+};
+const apiFlags = {
+	list: {
+		type: "boolean",
+		noNegate: true,
+		description: "List the API's operations"
+	},
+	spec: {
+		type: "string",
+		description: "Print the OpenAPI definition of an operationId or path"
+	},
+	method: {
+		type: "string",
+		short: "X",
+		description: "HTTP method; default GET, or POST with fields or a body"
+	},
+	header: {
+		type: "string",
+		short: "H",
+		multiple: true,
+		description: "Request header, 'Key: Value'"
+	},
+	field: {
+		type: "string",
+		short: "F",
+		multiple: true,
+		description: "key=value; true, false, null, and numbers are sent as JSON"
+	},
+	body: {
+		type: "string",
+		description: "Request body: inline, @file, or - for stdin"
+	},
+	paginate: {
+		type: "boolean",
+		noNegate: true,
+		description: "Fetch every page, printing each response body as one JSON line"
+	}
+};
+/**
+* Provides the {@link apiClient} Context and contributes `api`: `api --list` and
+* `api --spec <operationId|path>` read the spec (calling its loader, if any); `api <path>` sends
+* a request through the client, prints the response body to stdout, and fails with
+* {@link ApiResponseError} on a non-2xx status.
+*/
+const apiCommand = /* @__PURE__ */ defineExtension(API).factory((extension, { spec, paginate, ...client }) => extension.provide(apiClient(client)).add(defineCommand("api", { description: "Call the HTTP API, or browse its OpenAPI spec" }, (command) => command.use(apiClient).args(pathArg).flags(apiFlags).action(async ({ args, flags, ctx, signal, stdout }) => {
+	if (flags.list) {
+		for (const line of listOperations(await loadSpec(spec, signal))) stdout(line);
+		return;
+	}
+	if (flags.spec !== void 0) {
+		stdout(JSON.stringify(specFor(await loadSpec(spec, signal), flags.spec)));
+		return;
+	}
+	if (args.path === void 0) throw new CrustError("VALIDATION", "Missing required argument \"<path>\" (or pass --list or --spec)");
+	if (flags.paginate && paginate === void 0) throw new Error("--paginate: this CLI does not configure pagination");
+	let url;
+	try {
+		url = baseOriginUrl(client.baseUrl, args.path);
+	} catch (cause) {
+		const message = cause instanceof Error ? cause.message : String(cause);
+		throw new CrustError("PARSE", message, { argument: "path" }).withCause(cause);
+	}
+	const fields = (flags.field ?? []).map(parseField);
+	const body = flags.body === void 0 ? void 0 : await readBody(flags.body, signal);
+	const method = (flags.method ?? (fields.length > 0 || body !== void 0 ? "POST" : "GET")).toUpperCase();
+	const headers = new Headers((flags.header ?? []).map(parseHeader));
+	let path = args.path;
+	let requestBody = body;
+	if (fields.length > 0) {
+		if (body !== void 0 || method === "GET" || method === "HEAD") {
+			const query = new URLSearchParams(fields.map(([key, value]) => [key, String(value)])).toString();
+			url.search = url.search === "" ? query : `${url.search.slice(1)}&${query}`;
+			path = url.href;
+		} else requestBody = JSON.stringify(Object.fromEntries(fields));
+	}
+	if (requestBody !== void 0 && !headers.has("content-type")) headers.set("content-type", "application/json");
+	const api = await ctx.api;
+	let request = {
+		path,
+		init: {
+			method,
+			headers,
+			body: requestBody
+		}
+	};
+	let sentMethod = method;
+	let response = await api.fetch(request.path, request.init);
+	for (let pageNumber = 2;; pageNumber++) {
+		const page = flags.paginate ? response.clone() : void 0;
+		const text = await response.text();
+		if (flags.paginate) stdout(compactJson(text));
+		else if (text !== "") stdout(text.replace(/\r?\n$/, ""));
+		if (!response.ok) throw new ApiResponseError(response.status, `${request.init?.method ?? "GET"} ${request.path}: HTTP ${response.status} ${response.statusText}`.trimEnd());
+		const next = page && paginate ? await paginate(page) : void 0;
+		if (next === void 0) return;
+		const nextInit = next.init ?? request.init;
+		const nextUrl = resolveUrl(client.baseUrl, next.path).href;
+		const nextMethod = nextInit?.method ?? "GET";
+		if (nextInit === request.init && nextMethod === sentMethod && nextUrl === resolveUrl(client.baseUrl, request.path).href) throw new Error(`--paginate: page ${pageNumber} repeats the previous request (${nextMethod} ${nextUrl})`);
+		request = {
+			path: next.path,
+			init: nextInit
+		};
+		sentMethod = nextMethod;
+		response = await fetchNextPage(api, request.path, request.init);
+	}
+}))));
+/** A page body as one NDJSON line: JSON compacted, any other text (even empty) as a JSON string. */
+function compactJson(text) {
+	try {
+		JSON.parse(text);
+	} catch {
+		return JSON.stringify(text);
+	}
+	return text.replace(/"(?:[^"\\]|\\.)*"|\s+/g, (token) => token[0] === "\"" ? token : "");
+}
+export { ApiResponseError, apiClient, apiCommand };

package/package.json

@@ -1,17 +1,66 @@
 {
-	"name": "@crustjs/openapi",
-	"version": "0.0.0",
-	"description": "Placeholder for the first release of @crustjs/openapi. Do not install this version.",
-	"license": "MIT",
-	"author": "chenxin-yan",
-	"repository": {
-		"type": "git",
-		"url": "git+https://github.com/chenxin-yan/crust.git",
-		"directory": "packages/openapi"
-	},
-	"homepage": "https://crustjs.com",
-	"files": [],
-	"publishConfig": {
-		"access": "public"
-	}
-}
+  "name": "@crustjs/openapi",
+  "version": "0.1.0",
+  "description": "Call a CLI's HTTP API and browse its OpenAPI spec from an api command",
+  "type": "module",
+  "sideEffects": false,
+  "license": "MIT",
+  "author": "chenxin-yan",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/chenxin-yan/crust.git",
+    "directory": "packages/openapi"
+  },
+  "homepage": "https://crustjs.com",
+  "bugs": {
+    "url": "https://github.com/chenxin-yan/crust/issues"
+  },
+  "keywords": [
+    "cli",
+    "crust",
+    "openapi",
+    "api",
+    "http",
+    "bun"
+  ],
+  "files": [
+    "dist"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@crustjs/utils": "^0.3.0"
+  },
+  "devDependencies": {
+    "@crustjs/config": "0.0.0",
+    "@crustjs/core": "0.6.0",
+    "@crustjs/testing": "0.1.7",
+    "vite-plus": "1.4.0"
+  },
+  "peerDependencies": {
+    "@crustjs/core": "^0.6.0",
+    "typescript": "^7.0.0"
+  },
+  "peerDependenciesMeta": {
+    "typescript": {
+      "optional": true
+    }
+  },
+  "engines": {
+    "bun": ">=1.4.0",
+    "node": ">=24"
+  },
+  "scripts": {
+    "build": "vp run build:task",
+    "dev": "vp pack --watch",
+    "check:types": "vp run check:types:task",
+    "test": "vp run test:task"
+  }
+}