@theholocron/holocron-plugin-postman 2.0.0-alpha.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Newton Koumantzelis
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,74 @@
+# `@theholocron/holocron-plugin-postman`
+
+Postman plugin for [Holocron](../cli). Implements the **multi-cardinality**
+`tooling` capability against [Postman's REST API](https://learning.postman.com/docs/developer/postman-api/).
+
+## Why REST, not the CLI
+
+Postman ships a CLI (`postman`, the newer + more capable successor to
+`newman`), but for our `tooling` surface — collection / spec / environment
+**management** — REST is the canonical interface and avoids a system-binary
+dependency. The CLI is best suited for running collections (the newman use
+case); we sync, we don't run.
+
+## Auth
+
+Token resolution order:
+
+1. `--token <KEY>` flag on the holocron invocation
+2. `HOLOCRON_POSTMAN_API_KEY` env var
+3. `POSTMAN_API_KEY` env var (Postman's own standard)
+
+Generate the key at https://web.postman.co/settings/me/api-keys.
+
+## Config
+
+```jsonc
+{
+  "providers": {
+    "tooling": [
+      ["postman", {
+        "workspaceId": "00000000-0000-0000-0000-000000000000",
+        "specFile": "apps/api/openapi.json",
+        "specName": "Rando API",
+        "collectionName": "Rando API",
+        "envFiles": ["apps/api/postman-env-staging.json"]
+      }],
+      "storybook"
+    ]
+  }
+}
+```
+
+- `workspaceId` (required) — Postman workspace id. Find via `holocron tooling postman workspaces`.
+- `specFile` (optional) — relative path to the local OpenAPI JSON. `sync` reads + uploads this.
+- `specName` (optional) — display name in Postman's Spec Hub. Defaults to repo name.
+- `collectionName` (optional) — name for the imported collection. Defaults to `specName`.
+- `envFiles` (optional) — local Postman environment JSON files to push.
+
+## What's implemented
+
+| Method                       | What it does                                                  |
+| ---------------------------- | ------------------------------------------------------------- |
+| **Tooling interface**        |                                                               |
+| `sync()`                     | Reads `specFile`, upserts the Spec Hub spec, delete-then-imports the collection, find-or-creates each env in `envFiles`. |
+| `doctor()`                   | Probes `/me` + `/workspaces`; returns `{ ok, message }`.      |
+| **Postman-specific methods** (on `PostmanTooling`, not on the `Tooling` interface) | |
+| `getMyself`                  | `GET /me` — authed user identity.                             |
+| `listWorkspaces`             | `GET /workspaces`.                                            |
+| `findCollectionByName`       | `GET /collections?workspace=…` + name filter.                 |
+| `deleteCollection`           | `DELETE /collections/{uid}`.                                  |
+| `importOpenApi`              | `POST /import/openapi?workspace=…` with the spec stringified into `{ type: "string", input }`. |
+| `findEnvironmentByName`      | `GET /environments?workspace=…` + name filter.                |
+| `createEnvironment`          | `POST /environments?workspace=…`.                             |
+| `updateEnvironment`          | `PUT /environments/{uid}`.                                    |
+| `findSpecByName`             | `GET /specs?workspaceId=…` + name filter.                     |
+| `createSpec`                 | `POST /specs?workspaceId=…` (flat body — name/type are NOT wrapped under `spec`). |
+| `upsertSpecFile`             | `PATCH /specs/{id}/files/{path}` (PUT returns 404 here).      |
+
+## Status
+
+**v0.0.0 — first port.** Surface matches Rando's `adapters/postman.ts`.
+`PostmanPlanLimitError` is thrown when Postman responds with
+`limitReachedError` (e.g., Free-tier "0 APIs" cap) — callers can
+discriminate to render "upgrade required" instead of a raw API dump.

package/dist/index.d.mts

@@ -0,0 +1,192 @@
+import { Tooling, ToolingDoctorReport } from "@theholocron/cli";
+
+//#region src/auth.d.ts
+/**
+ * Token resolution for the Postman plugin.
+ *
+ * Resolution order:
+ *   1. explicit `cliToken` argument (from `--token` flag)
+ *   2. HOLOCRON_POSTMAN_API_KEY env var (preferred — explicit intent)
+ *   3. POSTMAN_API_KEY env var (Postman's own default)
+ */
+declare class AuthError extends Error {
+  name: string;
+}
+interface ResolveTokenInput {
+  /** From `--token` CLI flag. */
+  cliToken?: string;
+  /** Env vars; passed in for testability. Defaults to `process.env`. */
+  env?: NodeJS.ProcessEnv;
+}
+declare function resolveToken(input?: ResolveTokenInput): string;
+//#endregion
+//#region src/rest.d.ts
+/**
+ * Thin REST wrapper around api.getpostman.com.
+ *
+ * Same pattern as the github / vercel / neon / clerk REST clients —
+ * the Postman API uses `x-api-key` (not bearer) for auth, but
+ * otherwise the shape's identical: JSON only, transport-failure
+ * wrapping with `status: 0`.
+ */
+interface RestClientOptions {
+  token: string;
+  fetch?: typeof fetch;
+  baseUrl?: string;
+}
+interface RequestOptions {
+  method?: 'GET' | 'POST' | 'PATCH' | 'PUT' | 'DELETE';
+  body?: unknown;
+  query?: Record<string, string>;
+}
+declare class PostmanRestClient {
+  private readonly token;
+  private readonly fetchImpl;
+  readonly baseUrl: string;
+  constructor(opts: RestClientOptions);
+  request<T>(path: string, opts?: RequestOptions): Promise<T>;
+}
+//#endregion
+//#region src/capabilities/tooling.d.ts
+interface PostmanToolingOptions {
+  workspaceId: string;
+  /** Local OpenAPI JSON path (relative to repoRoot). */
+  specFile?: string;
+  /** Display name in Postman. Defaults to the OpenAPI spec's `info.title`. */
+  specName?: string;
+  /** Collection name to import the spec as. Defaults to specName. */
+  collectionName?: string;
+  /** Local Postman environment JSON files to push (relative to repoRoot). */
+  envFiles?: string[];
+  /** Working repo root. Defaults to process.cwd(). */
+  repoRoot?: string;
+}
+interface PostmanUser {
+  id: number;
+  username: string;
+  fullName: string;
+}
+interface PostmanWorkspace {
+  id: string;
+  name: string;
+  type: string;
+}
+interface PostmanCollection {
+  id: string;
+  uid: string;
+  name: string;
+}
+interface PostmanEnvironment {
+  id: string;
+  uid: string;
+  name: string;
+}
+interface PostmanSpec {
+  id: string;
+  name: string;
+  type: string;
+}
+declare class PostmanTooling implements Tooling {
+  private readonly rest;
+  readonly key: "tooling";
+  readonly providerName = "postman";
+  private readonly opts;
+  private readonly repoRoot;
+  constructor(rest: PostmanRestClient, opts: PostmanToolingOptions);
+  sync(): Promise<void>;
+  doctor(): Promise<ToolingDoctorReport>;
+  getMyself(): Promise<PostmanUser>;
+  listWorkspaces(): Promise<PostmanWorkspace[]>;
+  findCollectionByName(input: {
+    workspaceId: string;
+    name: string;
+  }): Promise<PostmanCollection | null>;
+  deleteCollection(uid: string): Promise<void>;
+  importOpenApi(input: {
+    workspaceId: string;
+    spec: unknown;
+  }): Promise<PostmanCollection>;
+  listEnvironments(input: {
+    workspaceId: string;
+  }): Promise<PostmanEnvironment[]>;
+  findEnvironmentByName(input: {
+    workspaceId: string;
+    name: string;
+  }): Promise<PostmanEnvironment | null>;
+  createEnvironment(input: {
+    workspaceId: string;
+    environment: unknown;
+  }): Promise<PostmanEnvironment>;
+  updateEnvironment(input: {
+    uid: string;
+    environment: unknown;
+  }): Promise<PostmanEnvironment>;
+  findSpecByName(input: {
+    workspaceId: string;
+    name: string;
+  }): Promise<PostmanSpec | null>;
+  createSpec(input: {
+    workspaceId: string;
+    name: string;
+    type?: string;
+    filePath?: string;
+    fileContent: string;
+  }): Promise<PostmanSpec>;
+  upsertSpecFile(input: {
+    specId: string;
+    filePath: string;
+    content: string;
+  }): Promise<void>;
+}
+//#endregion
+//#region src/errors.d.ts
+/**
+ * Postman-specific errors that callers might want to discriminate.
+ */
+/**
+ * Thrown when Postman returns a `limitReachedError` (e.g., a Free-tier
+ * account hitting the "0 APIs" cap). Callers can render "upgrade
+ * required" instead of dumping the raw API body.
+ */
+declare class PostmanPlanLimitError extends Error {
+  /** Human-readable plan-limit message from Postman. */
+  readonly limitMessage: string;
+  /** Original response body (JSON or text). */
+  readonly body: string;
+  name: string;
+  constructor(/** Human-readable plan-limit message from Postman. */
+
+  limitMessage: string, /** Original response body (JSON or text). */
+
+  body: string);
+}
+/**
+ * Inspect a Postman error body for the plan-limit shape. Returns the
+ * limit message when matched; null otherwise (caller throws a generic
+ * `ProviderApiError`).
+ */
+declare function detectPlanLimit(body: string): string | null;
+//#endregion
+//#region src/index.d.ts
+interface PostmanPluginOptions extends ResolveTokenInput, PostmanToolingOptions {
+  /** Working repo root. Used to resolve relative paths in specFile/envFiles. Defaults to process.cwd(). */
+  repoRoot?: string;
+  /** Override base URL for tests. */
+  baseUrl?: string;
+  /** Override `fetch` for tests. */
+  fetch?: typeof fetch;
+}
+interface PluginContext {
+  options: PostmanPluginOptions;
+  rest: PostmanRestClient;
+}
+declare function createContext(options: PostmanPluginOptions): PluginContext;
+declare function tooling(ctx: PluginContext): Tooling;
+declare function createPlugin(options: PostmanPluginOptions): {
+  name: string;
+  capabilities: {
+    tooling: () => Tooling;
+  };
+};
+//#endregion
+export { AuthError, PluginContext, PostmanPlanLimitError, PostmanPluginOptions, PostmanRestClient, PostmanTooling, ResolveTokenInput, createContext, createPlugin, detectPlanLimit, resolveToken, tooling };

package/dist/index.mjs

@@ -0,0 +1,350 @@
+import { readFile } from "node:fs/promises";
+import { basename, resolve } from "node:path";
+import { ProviderApiError } from "@theholocron/cli";
+//#region src/auth.ts
+/**
+* Token resolution for the Postman plugin.
+*
+* Resolution order:
+*   1. explicit `cliToken` argument (from `--token` flag)
+*   2. HOLOCRON_POSTMAN_API_KEY env var (preferred — explicit intent)
+*   3. POSTMAN_API_KEY env var (Postman's own default)
+*/
+var AuthError = class extends Error {
+	name = "AuthError";
+};
+function resolveToken(input = {}) {
+	const env = input.env ?? process.env;
+	const token = input.cliToken || env.HOLOCRON_POSTMAN_API_KEY || env.POSTMAN_API_KEY;
+	if (!token) throw new AuthError("no Postman API key found. Pass --token <KEY>, or set HOLOCRON_POSTMAN_API_KEY / POSTMAN_API_KEY.");
+	return token;
+}
+//#endregion
+//#region src/capabilities/tooling.ts
+/**
+* `tooling` capability for Postman.
+*
+* Ported from rando-id/rando.id `adapters/postman.ts`. The holocron
+* `Tooling` interface stays narrow (`sync` + `doctor`); the
+* Postman-specific surface (workspaces, collections, environments,
+* Spec Hub) lives as additional methods on this class for callers
+* that need direct access.
+*
+* `sync()` flow:
+*   1. Read the local OpenAPI spec from `options.specFile`
+*   2. Find or create the Spec Hub spec by name in the workspace;
+*      upsert the spec file content
+*   3. Find any existing collection with the same name and delete it
+*      (Postman's import-from-OpenAPI path is create-only — no stable
+*      update path for collections produced from a spec)
+*   4. Import the spec as a fresh collection
+*   5. For each `envFiles[i]`, find-or-create the environment
+*
+* `doctor()` probes `/me` for auth + `/workspaces` for workspace
+* reachability and returns a `ToolingDoctorReport`.
+*/
+var PostmanTooling = class {
+	rest;
+	key = "tooling";
+	providerName = "postman";
+	opts;
+	repoRoot;
+	constructor(rest, opts) {
+		this.rest = rest;
+		if (!opts.workspaceId) throw new Error("PostmanTooling requires `workspaceId` in options");
+		this.opts = opts;
+		this.repoRoot = opts.repoRoot ?? process.cwd();
+	}
+	async sync() {
+		if (!this.opts.specFile) throw new Error("PostmanTooling.sync() requires `specFile` in options (local OpenAPI JSON path)");
+		const specPath = resolve(this.repoRoot, this.opts.specFile);
+		const specText = await readFile(specPath, "utf8");
+		const specObj = JSON.parse(specText);
+		const inferredName = specObj.info?.title ?? basename(specPath);
+		const specName = this.opts.specName ?? inferredName;
+		const collectionName = this.opts.collectionName ?? specName;
+		const existingSpec = await this.findSpecByName({
+			workspaceId: this.opts.workspaceId,
+			name: specName
+		});
+		if (existingSpec) await this.upsertSpecFile({
+			specId: existingSpec.id,
+			filePath: "index.json",
+			content: specText
+		});
+		else await this.createSpec({
+			workspaceId: this.opts.workspaceId,
+			name: specName,
+			fileContent: specText
+		});
+		const existingCollection = await this.findCollectionByName({
+			workspaceId: this.opts.workspaceId,
+			name: collectionName
+		});
+		if (existingCollection) await this.deleteCollection(existingCollection.uid);
+		await this.importOpenApi({
+			workspaceId: this.opts.workspaceId,
+			spec: specObj
+		});
+		for (const file of this.opts.envFiles ?? []) {
+			const envText = await readFile(resolve(this.repoRoot, file), "utf8");
+			const envObj = JSON.parse(envText);
+			if (!envObj.name) throw new Error(`Postman environment file ${file} is missing a "name" field`);
+			const existing = await this.findEnvironmentByName({
+				workspaceId: this.opts.workspaceId,
+				name: envObj.name
+			});
+			if (existing) await this.updateEnvironment({
+				uid: existing.uid,
+				environment: envObj
+			});
+			else await this.createEnvironment({
+				workspaceId: this.opts.workspaceId,
+				environment: envObj
+			});
+		}
+	}
+	async doctor() {
+		try {
+			const me = await this.getMyself();
+			const found = (await this.listWorkspaces()).find((w) => w.id === this.opts.workspaceId);
+			if (!found) return {
+				ok: false,
+				message: `authed as ${me.username}, but workspace ${this.opts.workspaceId} not visible`
+			};
+			return {
+				ok: true,
+				message: `authed as ${me.username}; workspace ${found.name} (${found.type}) accessible`
+			};
+		} catch (err) {
+			return {
+				ok: false,
+				message: err instanceof Error ? err.message : String(err)
+			};
+		}
+	}
+	async getMyself() {
+		const raw = await this.rest.request("/me");
+		return {
+			id: raw.user.id,
+			username: raw.user.username,
+			fullName: raw.user.fullName
+		};
+	}
+	async listWorkspaces() {
+		return (await this.rest.request("/workspaces")).workspaces.map((w) => ({
+			id: w.id,
+			name: w.name,
+			type: w.type
+		}));
+	}
+	async findCollectionByName(input) {
+		const match = (await this.rest.request("/collections", { query: { workspace: input.workspaceId } })).collections.find((c) => c.name === input.name);
+		return match ? {
+			id: match.id,
+			uid: match.uid,
+			name: match.name
+		} : null;
+	}
+	async deleteCollection(uid) {
+		await this.rest.request(`/collections/${encodeURIComponent(uid)}`, { method: "DELETE" });
+	}
+	async importOpenApi(input) {
+		const created = (await this.rest.request("/import/openapi", {
+			method: "POST",
+			query: { workspace: input.workspaceId },
+			body: {
+				type: "string",
+				input: typeof input.spec === "string" ? input.spec : JSON.stringify(input.spec)
+			}
+		})).collections[0];
+		if (!created) throw new ProviderApiError("Postman returned no collection on import — check the OpenAPI spec is well-formed", 500, void 0);
+		return {
+			id: created.id,
+			uid: created.uid,
+			name: created.name
+		};
+	}
+	async listEnvironments(input) {
+		return (await this.rest.request("/environments", { query: { workspace: input.workspaceId } })).environments.map((e) => ({
+			id: e.id,
+			uid: e.uid,
+			name: e.name
+		}));
+	}
+	async findEnvironmentByName(input) {
+		return (await this.listEnvironments(input)).find((e) => e.name === input.name) ?? null;
+	}
+	async createEnvironment(input) {
+		const raw = await this.rest.request("/environments", {
+			method: "POST",
+			query: { workspace: input.workspaceId },
+			body: { environment: input.environment }
+		});
+		return {
+			id: raw.environment.id,
+			uid: raw.environment.uid,
+			name: raw.environment.name
+		};
+	}
+	async updateEnvironment(input) {
+		const raw = await this.rest.request(`/environments/${encodeURIComponent(input.uid)}`, {
+			method: "PUT",
+			body: { environment: input.environment }
+		});
+		return {
+			id: raw.environment.id,
+			uid: raw.environment.uid,
+			name: raw.environment.name
+		};
+	}
+	async findSpecByName(input) {
+		const match = (await this.rest.request("/specs", { query: { workspaceId: input.workspaceId } })).specs.find((s) => s.name === input.name);
+		return match ? {
+			id: match.id,
+			name: match.name,
+			type: match.type
+		} : null;
+	}
+	async createSpec(input) {
+		const raw = await this.rest.request("/specs", {
+			method: "POST",
+			query: { workspaceId: input.workspaceId },
+			body: {
+				name: input.name,
+				type: input.type ?? "OPENAPI:3.0",
+				files: [{
+					path: input.filePath ?? "index.json",
+					content: input.fileContent
+				}]
+			}
+		});
+		return {
+			id: raw.id,
+			name: raw.name,
+			type: raw.type
+		};
+	}
+	async upsertSpecFile(input) {
+		await this.rest.request(`/specs/${encodeURIComponent(input.specId)}/files/${encodeURIComponent(input.filePath)}`, {
+			method: "PATCH",
+			body: { content: input.content }
+		});
+	}
+};
+//#endregion
+//#region src/errors.ts
+/**
+* Postman-specific errors that callers might want to discriminate.
+*/
+/**
+* Thrown when Postman returns a `limitReachedError` (e.g., a Free-tier
+* account hitting the "0 APIs" cap). Callers can render "upgrade
+* required" instead of dumping the raw API body.
+*/
+var PostmanPlanLimitError = class extends Error {
+	limitMessage;
+	body;
+	name = "PostmanPlanLimitError";
+	constructor(limitMessage, body) {
+		super(limitMessage);
+		this.limitMessage = limitMessage;
+		this.body = body;
+	}
+};
+/**
+* Inspect a Postman error body for the plan-limit shape. Returns the
+* limit message when matched; null otherwise (caller throws a generic
+* `ProviderApiError`).
+*/
+function detectPlanLimit(body) {
+	try {
+		const parsed = JSON.parse(body);
+		if (parsed.error?.name === "limitReachedError" && parsed.error.message) return parsed.error.message;
+	} catch {}
+	return null;
+}
+//#endregion
+//#region src/rest.ts
+/**
+* Thin REST wrapper around api.getpostman.com.
+*
+* Same pattern as the github / vercel / neon / clerk REST clients —
+* the Postman API uses `x-api-key` (not bearer) for auth, but
+* otherwise the shape's identical: JSON only, transport-failure
+* wrapping with `status: 0`.
+*/
+var PostmanRestClient = class {
+	token;
+	fetchImpl;
+	baseUrl;
+	constructor(opts) {
+		this.token = opts.token;
+		this.fetchImpl = opts.fetch ?? globalThis.fetch;
+		this.baseUrl = (opts.baseUrl ?? "https://api.getpostman.com").replace(/\/+$/, "");
+	}
+	async request(path, opts = {}) {
+		const url = new URL(`${this.baseUrl}${path.startsWith("/") ? path : "/" + path}`);
+		for (const [k, v] of Object.entries(opts.query ?? {})) url.searchParams.set(k, v);
+		const fullUrl = url.toString();
+		const headers = {
+			"x-api-key": this.token,
+			accept: "application/json"
+		};
+		const init = {
+			method: opts.method ?? "GET",
+			headers
+		};
+		if (opts.body !== void 0) {
+			headers["content-type"] = "application/json";
+			init.body = JSON.stringify(opts.body);
+		}
+		let res;
+		try {
+			res = await this.fetchImpl(fullUrl, init);
+		} catch (err) {
+			const detail = err instanceof Error ? `${err.name}: ${err.message}` : String(err);
+			throw new ProviderApiError(`Postman ${init.method} ${path} failed: ${detail}`, 0, void 0);
+		}
+		if (!res.ok) {
+			const body = await res.text().catch(() => "");
+			const limit = detectPlanLimit(body);
+			if (limit) throw new PostmanPlanLimitError(limit, body);
+			throw new ProviderApiError(`Postman ${init.method} ${path} → ${res.status}`, res.status, body);
+		}
+		if (res.status === 204) return void 0;
+		const text = await res.text();
+		if (!text) return void 0;
+		return JSON.parse(text);
+	}
+};
+//#endregion
+//#region src/index.ts
+function createContext(options) {
+	if (!options.workspaceId) throw new Error("@theholocron/holocron-plugin-postman requires `workspaceId` in options");
+	const restOpts = { token: resolveToken(options) };
+	if (options.baseUrl !== void 0) restOpts.baseUrl = options.baseUrl;
+	if (options.fetch !== void 0) restOpts.fetch = options.fetch;
+	return {
+		options,
+		rest: new PostmanRestClient(restOpts)
+	};
+}
+function tooling(ctx) {
+	const opts = { workspaceId: ctx.options.workspaceId };
+	if (ctx.options.specFile !== void 0) opts.specFile = ctx.options.specFile;
+	if (ctx.options.specName !== void 0) opts.specName = ctx.options.specName;
+	if (ctx.options.collectionName !== void 0) opts.collectionName = ctx.options.collectionName;
+	if (ctx.options.envFiles !== void 0) opts.envFiles = ctx.options.envFiles;
+	if (ctx.options.repoRoot !== void 0) opts.repoRoot = ctx.options.repoRoot;
+	return new PostmanTooling(ctx.rest, opts);
+}
+function createPlugin(options) {
+	const ctx = createContext(options);
+	return {
+		name: "@theholocron/holocron-plugin-postman",
+		capabilities: { tooling: () => tooling(ctx) }
+	};
+}
+//#endregion
+export { AuthError, PostmanPlanLimitError, PostmanRestClient, PostmanTooling, createContext, createPlugin, detectPlanLimit, resolveToken, tooling };

package/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "@theholocron/holocron-plugin-postman",
+  "version": "2.0.0-alpha.0",
+  "description": "Holocron plugin for Postman. Implements the tooling capability against Postman's REST API — workspace + collection + spec + environment sync.",
+  "homepage": "https://github.com/theholocron/holocron/tree/main/packages/holocron-plugin-postman#readme",
+  "bugs": "https://github.com/theholocron/holocron/issues",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/theholocron/holocron.git",
+    "directory": "packages/holocron-plugin-postman"
+  },
+  "license": "MIT",
+  "author": "Newton Koumantzelis",
+  "type": "module",
+  "main": "./dist/index.mjs",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.mts",
+      "import": "./dist/index.mjs",
+      "default": "./dist/index.mjs"
+    }
+  },
+  "peerDependencies": {
+    "@theholocron/cli": "2.0.0-alpha.0"
+  },
+  "devDependencies": {
+    "@theholocron/tsconfig": "^4.1.0",
+    "@tsconfig/node-lts": "^24.0.0",
+    "@vitest/coverage-v8": "^3.2.6",
+    "eslint": "^9.36.0",
+    "globals": "^16.5.0",
+    "typescript": "^5.9.3",
+    "vitest": "^3.2.6",
+    "tsdown": "^0.22.3",
+    "@theholocron/cli": "2.0.0-alpha.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsdown",
+    "lint": "eslint .",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage"
+  },
+  "types": "./dist/index.d.mts"
+}