specli 0.0.2 → 0.0.4

package/README.md

@@ -201,50 +201,6 @@ Implementation notes:
 
 ## Request Bodies
 
-### Selecting the Body Input
-
-If an operation has a `requestBody`, you may provide a body via:
-
-- `--data <string>`
-- `--file <path>`
-- Body field flags (JSON-only; see below)
-
-Rules:
-
-- `--data` and `--file` are mutually exclusive.
-- Body field flags cannot be used with `--data` or `--file`.
-- If `requestBody.required` is true and you provide none of the above, the command fails with:
-  - `Missing request body. Provide --data, --file, or body field flags.`
-
-### Content-Type
-
-`Content-Type` is chosen as:
-
-1. `--content-type` (explicit override)
-2. The preferred content type derived from the OpenAPI requestBody (prefers `application/json` when present)
-
-### JSON Parsing + Normalization
-
-If the selected `Content-Type` includes `json`:
-
-- `--data`/`--file` content is parsed as either JSON or YAML
-- the request is sent as normalized JSON (`JSON.stringify(parsed)`)
-
-If `Content-Type` does not include `json`:
-
-- the body is treated as a raw string
-
-### Schema Validation (Ajv)
-
-specli uses Ajv (best-effort, `strict: false`) to validate:
-
-- query/header/cookie params
-- JSON request bodies when a requestBody schema is available
-
-Validation errors are formatted into a readable multiline message. For `required` errors, the message is normalized to:
-
-- `/<path> missing required property '<name>'`
-
 ### Body Field Flags
 
 When an operation has a `requestBody` and the preferred schema is a JSON object, specli generates convenience flags that match the property names:
@@ -299,11 +255,11 @@ Which produces:
 
 Notes / edge cases:
 
-- Body field flags are only supported for JSON bodies. If you try to use them without a JSON content type, specli errors.
-- Required fields in the schema are checked in a "friendly" way:
-  - `Missing required body field 'name'. Provide --name or use --data/--file.`
-- If a body field flag conflicts with an operation parameter flag, the operation parameter takes precedence.
-- Numeric coercion uses `Number(...)` / `parseInt(...)`. Today it does not explicitly reject `NaN` (this is an area to harden).
+- Body field flags are only supported for JSON bodies.
+- Required fields in the schema are checked with friendly error messages:
+  - `Missing required body field 'name'. Provide --name.`
+- If a body field flag would conflict with an operation parameter flag or `--curl`, the operation parameter takes precedence.
+- Numeric coercion uses `Number(...)` / `parseInt(...)`.
 
 ## Servers
 

package/package.json

@@ -2,7 +2,7 @@
 	"name": "specli",
 	"module": "index.ts",
 	"type": "module",
-	"version": "0.0.2",
+	"version": "0.0.4",
 	"bin": {
 		"specli": "./cli.ts"
 	},

package/src/cli/compile.ts

@@ -65,18 +65,23 @@ export async function compileCommand(
 
 	buildArgs.push("./src/compiled.ts");
 
+	// Only set env vars that have actual values - avoid empty strings
+	// because the macros will embed them and they will override defaults.
+	const buildEnv: Record<string, string> = {
+		...process.env,
+		SPECLI_SPEC: spec,
+		SPECLI_NAME: name,
+	};
+	if (options.server) buildEnv.SPECLI_SERVER = options.server;
+	if (options.serverVar?.length)
+		buildEnv.SPECLI_SERVER_VARS = options.serverVar.join(",");
+	if (options.auth) buildEnv.SPECLI_AUTH = options.auth;
+
 	const proc = Bun.spawn({
 		cmd: ["bun", ...buildArgs],
 		stdout: "pipe",
 		stderr: "pipe",
-		env: {
-			...process.env,
-			SPECLI_SPEC: spec,
-			SPECLI_NAME: name,
-			SPECLI_SERVER: options.server ?? "",
-			SPECLI_SERVER_VARS: options.serverVar?.join(",") ?? "",
-			SPECLI_AUTH: options.auth ?? "",
-		},
+		env: buildEnv,
 	});
 
 	const output = await new Response(proc.stdout).text();

package/src/cli/runtime/execute.ts

@@ -34,92 +34,47 @@ export async function executeAction(input: ExecuteInput): Promise<void> {
 			return;
 		}
 
-		if (input.globals.dryRun) {
-			process.stdout.write(`${request.method} ${request.url}\n`);
-			for (const [k, v] of request.headers.entries()) {
-				process.stdout.write(`${k}: ${v}\n`);
-			}
-			if (request.body) {
-				const text = await request.clone().text();
-				if (text) process.stdout.write(`\n${text}\n`);
-			}
-			return;
-		}
-
-		const timeoutMs = input.globals.timeout
-			? Number(input.globals.timeout)
-			: undefined;
-		let timeout: Timer | undefined;
-		let controller: AbortController | undefined;
-		if (timeoutMs && Number.isFinite(timeoutMs) && timeoutMs > 0) {
-			controller = new AbortController();
-			timeout = setTimeout(() => controller?.abort(), timeoutMs);
-		}
+		const res = await fetch(request);
+		const contentType = res.headers.get("content-type") ?? "";
+		const status = res.status;
 
-		try {
-			const res = await fetch(request, { signal: controller?.signal });
-			const contentType = res.headers.get("content-type") ?? "";
-			const status = res.status;
+		const text = await res.text();
+		let body: unknown = text;
+		let parsedJson: unknown | undefined;
 
-			const text = await res.text();
-			let body: unknown = text;
-			let parsedJson: unknown | undefined;
-
-			if (contentType.includes("json")) {
-				try {
-					parsedJson = text ? JSON.parse(text) : null;
-					body = parsedJson;
-				} catch {
-					// keep as text
-				}
-			}
-
-			if (!res.ok) {
-				if (input.globals.json) {
-					process.stdout.write(
-						`${JSON.stringify({
-							status,
-							body,
-							headers: input.globals.headers
-								? Object.fromEntries(res.headers.entries())
-								: undefined,
-						})}\n`,
-					);
-				} else {
-					process.stderr.write(`HTTP ${status}\n`);
-					process.stderr.write(
-						`${typeof body === "string" ? body : JSON.stringify(body, null, 2)}\n`,
-					);
-				}
-				process.exitCode = 1;
-				return;
+		if (contentType.includes("json")) {
+			try {
+				parsedJson = text ? JSON.parse(text) : null;
+				body = parsedJson;
+			} catch {
+				// keep as text
 			}
+		}
 
+		if (!res.ok) {
 			if (input.globals.json) {
-				const payload: unknown =
-					input.globals.status || input.globals.headers
-						? {
-								status: input.globals.status ? status : undefined,
-								headers: input.globals.headers
-									? Object.fromEntries(res.headers.entries())
-									: undefined,
-								body,
-							}
-						: body;
-
-				process.stdout.write(`${JSON.stringify(payload)}\n`);
-				return;
-			}
-
-			// default (human + agent readable)
-			if (typeof parsedJson !== "undefined") {
-				process.stdout.write(`${JSON.stringify(parsedJson, null, 2)}\n`);
+				process.stdout.write(`${JSON.stringify({ status, body })}\n`);
 			} else {
-				process.stdout.write(text);
-				if (!text.endsWith("\n")) process.stdout.write("\n");
+				process.stderr.write(`HTTP ${status}\n`);
+				process.stderr.write(
+					`${typeof body === "string" ? body : JSON.stringify(body, null, 2)}\n`,
+				);
 			}
-		} finally {
-			if (timeout) clearTimeout(timeout);
+			process.exitCode = 1;
+			return;
+		}
+
+		if (input.globals.json) {
+			process.stdout.write(`${JSON.stringify(body)}\n`);
+			return;
+		}
+
+		// default (human + agent readable)
+		if (typeof parsedJson !== "undefined") {
+			process.stdout.write(`${JSON.stringify(parsedJson, null, 2)}\n`);
+		} else {
+			process.stdout.write(text);
+			if (!text.endsWith("\n")) process.stdout.write("\n");
 		}
 	} catch (err) {
 		const message = err instanceof Error ? err.message : String(err);

package/src/cli/runtime/generated.ts

@@ -5,7 +5,6 @@ import type { CommandModel } from "../command-model.ts";
 import type { ServerInfo } from "../server.ts";
 
 import { type BodyFlagDef, generateBodyFlags } from "./body-flags.ts";
-import { collectRepeatable } from "./collect.ts";
 import { executeAction } from "./execute.ts";
 import type { EmbeddedDefaults } from "./request.ts";
 import { coerceArrayInput, coerceValue } from "./validate/index.ts";
@@ -78,54 +77,21 @@ export function addGeneratedCommands(
 				else cmd.option(key, desc, parser);
 			}
 
-			const reservedFlags = new Set(action.flags.map((f) => f.flag));
+			// Collect reserved flags: operation params + --curl
+			const operationFlags = new Set(action.flags.map((f) => f.flag));
+			const reservedFlags = new Set([...operationFlags, "--curl"]);
 
-			// Common curl-replacement options.
-			// Only add flags that don't conflict with operation flags.
-			if (!reservedFlags.has("--header")) {
-				cmd.option(
-					"--header <header>",
-					"Extra header (repeatable)",
-					collectRepeatable,
-				);
-			}
-			if (!reservedFlags.has("--accept")) {
-				cmd.option("--accept <type>", "Override Accept header");
-			}
-			if (!reservedFlags.has("--status")) {
-				cmd.option("--status", "Include status in --json output");
-			}
-			if (!reservedFlags.has("--headers")) {
-				cmd.option("--headers", "Include headers in --json output");
-			}
-			if (!reservedFlags.has("--dry-run")) {
-				cmd.option("--dry-run", "Print request without sending");
-			}
-			if (!reservedFlags.has("--curl")) {
+			// Only --curl is a built-in flag (for debugging)
+			if (!operationFlags.has("--curl")) {
 				cmd.option("--curl", "Print curl command without sending");
 			}
-			if (!reservedFlags.has("--timeout")) {
-				cmd.option("--timeout <ms>", "Request timeout in milliseconds");
-			}
 
 			// Track body flag definitions for this action
 			let bodyFlagDefs: BodyFlagDef[] = [];
 
 			if (action.requestBody) {
-				if (!reservedFlags.has("--data")) {
-					cmd.option("--data <data>", "Inline request body");
-				}
-				if (!reservedFlags.has("--file")) {
-					cmd.option("--file <path>", "Request body from file");
-				}
-				if (!reservedFlags.has("--content-type")) {
-					cmd.option(
-						"--content-type <type>",
-						"Override Content-Type (defaults from OpenAPI)",
-					);
-				}
-
 				// Generate body flags from schema (recursive with dot notation)
+				// Pass reserved flags to avoid conflicts with operation params and --curl
 				bodyFlagDefs = generateBodyFlags(
 					action.requestBodySchema,
 					reservedFlags,

package/src/cli/runtime/request.ts

@@ -2,8 +2,6 @@ import type { AuthScheme } from "../auth-schemes.ts";
 import type { CommandAction } from "../command-model.ts";
 
 import { resolveAuthScheme } from "./auth/resolve.ts";
-import { loadBody, parseBodyAsJsonOrYaml } from "./body.ts";
-import { parseHeaderInput } from "./headers.ts";
 import { getToken } from "./profile/secrets.ts";
 import { getProfile, readProfiles } from "./profile/store.ts";
 import { resolveServerUrl } from "./server-url.ts";
@@ -19,18 +17,7 @@ export type RuntimeGlobals = {
 	server?: string;
 	serverVar?: string[];
 
-	// Common runtime flags.
-	header?: string[];
-	accept?: string;
-	contentType?: string;
-	data?: string;
-	file?: string;
-	timeout?: string;
-	dryRun?: boolean;
 	curl?: boolean;
-	status?: boolean;
-	headers?: boolean;
-
 	json?: boolean;
 
 	auth?: string;
@@ -201,14 +188,14 @@ export async function buildRequest(
 
 	const path = applyTemplate(input.action.path, pathVars, { encode: true });
 
-	const url = new URL(
-		path,
-		serverUrl.endsWith("/") ? serverUrl : `${serverUrl}/`,
-	);
+	// Build the full URL by combining server URL and path.
+	// We need to handle the case where path starts with "/" carefully:
+	// URL constructor treats absolute paths as relative to origin, not base path.
+	const baseUrl = serverUrl.endsWith("/") ? serverUrl : `${serverUrl}/`;
+	const relativePath = path.startsWith("/") ? path.slice(1) : path;
+	const url = new URL(relativePath, baseUrl);
 
 	const headers = new Headers();
-	const accept = input.globals.accept;
-	if (accept) headers.set("Accept", accept);
 
 	// Collect declared params for validation.
 	const queryValues: Record<string, unknown> = {};
@@ -273,51 +260,29 @@ export async function buildRequest(
 		headers.set("Cookie", existing ? `${existing}; ${part}` : part);
 	}
 
-	const extraHeaders = (input.globals.header ?? []).map(parseHeaderInput);
-	for (const { name, value } of extraHeaders) {
-		headers.set(name, value);
-	}
-
 	let body: string | undefined;
 	if (input.action.requestBody) {
-		const data = input.globals.data;
-		const file = input.globals.file;
-
-		const hasData = typeof data === "string";
-		const hasFile = typeof file === "string";
-
 		// Check if any body flags were provided using the flag definitions
 		const bodyFlagDefs = input.bodyFlagDefs ?? [];
-		const hasExpandedBody = bodyFlagDefs.some((def) => {
+		const hasBodyFlags = bodyFlagDefs.some((def) => {
 			// Commander keeps dots in option names: --address.street -> "address.street"
 			const dotKey = def.path.join(".");
 			return input.flagValues[dotKey] !== undefined;
 		});
 
-		if (hasData && hasFile) throw new Error("Use only one of --data or --file");
-		if (hasExpandedBody && (hasData || hasFile)) {
-			throw new Error(
-				"Use either --data/--file or body field flags (not both)",
-			);
-		}
-
-		const contentType =
-			input.globals.contentType ??
-			input.action.requestBody.preferredContentType;
+		const contentType = input.action.requestBody.preferredContentType;
 		if (contentType) headers.set("Content-Type", contentType);
 
 		const schema = input.action.requestBodySchema;
 
-		if (!hasExpandedBody && !hasData && !hasFile) {
+		if (!hasBodyFlags) {
 			if (input.action.requestBody.required) {
-				throw new Error(
-					"Missing request body. Provide --data, --file, or body field flags.",
-				);
+				throw new Error("Missing required request body fields.");
 			}
-		} else if (hasExpandedBody) {
+		} else {
 			if (!contentType?.includes("json")) {
 				throw new Error(
-					"Body field flags are only supported for JSON request bodies. Use --content-type application/json or --data/--file.",
+					"Body field flags are only supported for JSON request bodies.",
 				);
 			}
 
@@ -328,7 +293,7 @@ export async function buildRequest(
 			const missing = findMissingRequired(input.flagValues, bodyFlagDefs);
 			if (missing.length > 0) {
 				throw new Error(
-					`Missing required body field '${missing[0]}'. Provide --${missing[0]} or use --data/--file.`,
+					`Missing required body field '${missing[0]}'. Provide --${missing[0]}.`,
 				);
 			}
 
@@ -343,47 +308,6 @@ export async function buildRequest(
 			}
 
 			body = JSON.stringify(built);
-		} else if (hasData) {
-			if (contentType?.includes("json")) {
-				const parsed = parseBodyAsJsonOrYaml(data as string);
-
-				if (schema) {
-					const validate = ajv.compile(schema);
-					if (!validate(parsed)) {
-						throw new Error(formatAjvErrors(validate.errors));
-					}
-				}
-
-				body = JSON.stringify(parsed);
-			} else {
-				body = data as string;
-			}
-		} else if (hasFile) {
-			const loaded = await loadBody({
-				kind: "file",
-				path: file as string,
-			});
-			if (contentType?.includes("json")) {
-				const parsed = parseBodyAsJsonOrYaml(loaded?.raw ?? "");
-
-				if (schema) {
-					const validate = ajv.compile(schema);
-					if (!validate(parsed)) {
-						throw new Error(formatAjvErrors(validate.errors));
-					}
-				}
-
-				body = JSON.stringify(parsed);
-			} else {
-				body = loaded?.raw;
-			}
-		}
-	} else {
-		if (
-			typeof input.globals.data === "string" ||
-			typeof input.globals.file === "string"
-		) {
-			throw new Error("This operation does not accept a request body");
 		}
 	}
 

package/src/cli/runtime/server-url.ts

@@ -9,7 +9,8 @@ export type ResolveServerInput = {
 };
 
 export function resolveServerUrl(input: ResolveServerInput): string {
-	const base = input.serverOverride ?? input.servers[0]?.url;
+	// Treat empty string as undefined (serverOverride can come from env vars or profiles)
+	const base = input.serverOverride || input.servers[0]?.url;
 	if (!base) {
 		throw new Error(
 			"No server URL found. Provide --server <url> or define servers in the OpenAPI spec.",