specli 0.0.11 → 0.0.13

package/src/cli/runtime/request.ts

@@ -1,390 +0,0 @@
-import type { AuthScheme } from "../auth-schemes.ts";
-import type { CommandAction } from "../command-model.ts";
-
-import { resolveAuthScheme } from "./auth/resolve.ts";
-import { getToken } from "./profile/secrets.ts";
-import { getProfile, readProfiles } from "./profile/store.ts";
-import { resolveServerUrl } from "./server-url.ts";
-import { applyTemplate } from "./template.ts";
-import {
-	createAjv,
-	deriveValidationSchemas,
-	formatAjvErrors,
-} from "./validate/index.ts";
-
-export type RuntimeGlobals = {
-	spec?: string;
-	server?: string;
-	serverVar?: string[];
-
-	curl?: boolean;
-	json?: boolean;
-
-	auth?: string;
-	bearerToken?: string;
-	oauthToken?: string;
-	username?: string;
-	password?: string;
-	apiKey?: string;
-};
-
-function parseKeyValuePairs(
-	pairs: string[] | undefined,
-): Record<string, string> {
-	const out: Record<string, string> = {};
-	for (const pair of pairs ?? []) {
-		const idx = pair.indexOf("=");
-		if (idx === -1)
-			throw new Error(`Invalid pair '${pair}', expected name=value`);
-		const name = pair.slice(0, idx).trim();
-		const value = pair.slice(idx + 1).trim();
-		if (!name) throw new Error(`Invalid pair '${pair}', missing name`);
-		out[name] = value;
-	}
-	return out;
-}
-
-function _parseTimeoutMs(value: string | undefined): number | undefined {
-	if (!value) return undefined;
-	const n = Number(value);
-	if (!Number.isFinite(n) || n <= 0)
-		throw new Error("--timeout must be a positive number");
-	return n;
-}
-
-function pickAuthSchemeKey(
-	action: CommandAction,
-	globals: RuntimeGlobals,
-): string | undefined {
-	if (globals.auth) return globals.auth;
-
-	// If operation declares a single requirement set with a single scheme, default to it.
-	const req = action.auth.alternatives;
-	if (req.length === 1 && req[0]?.length === 1) {
-		return req[0][0]?.key;
-	}
-
-	return undefined;
-}
-
-function applyAuth(
-	headers: Headers,
-	url: URL,
-	action: CommandAction,
-	globals: RuntimeGlobals,
-	authSchemes: AuthScheme[],
-): { headers: Headers; url: URL } {
-	const schemeKey = pickAuthSchemeKey(action, globals);
-	if (!schemeKey) return { headers, url };
-
-	const scheme = authSchemes.find((s) => s.key === schemeKey);
-	if (!scheme) {
-		throw new Error(
-			`Unknown auth scheme '${schemeKey}'. Available: ${authSchemes
-				.map((s) => s.key)
-				.join(", ")}`,
-		);
-	}
-
-	if (
-		scheme.kind === "http-bearer" ||
-		scheme.kind === "oauth2" ||
-		scheme.kind === "openIdConnect"
-	) {
-		const token = globals.bearerToken ?? globals.oauthToken;
-		if (!token)
-			throw new Error("Missing token. Provide --bearer-token <token>.");
-		headers.set("Authorization", `Bearer ${token}`);
-		return { headers, url };
-	}
-
-	if (scheme.kind === "http-basic") {
-		if (!globals.username) throw new Error("Missing --username for basic auth");
-		if (!globals.password) throw new Error("Missing --password for basic auth");
-		const raw = `${globals.username}:${globals.password}`;
-		const encoded = Buffer.from(raw, "utf8").toString("base64");
-		headers.set("Authorization", `Basic ${encoded}`);
-		return { headers, url };
-	}
-
-	if (scheme.kind === "api-key") {
-		if (!scheme.name)
-			throw new Error(`apiKey scheme '${scheme.key}' missing name`);
-		if (!scheme.in)
-			throw new Error(`apiKey scheme '${scheme.key}' missing location`);
-		if (!globals.apiKey) throw new Error("Missing --api-key for apiKey auth");
-
-		if (scheme.in === "header") {
-			headers.set(scheme.name, globals.apiKey);
-		}
-		if (scheme.in === "query") {
-			url.searchParams.set(scheme.name, globals.apiKey);
-		}
-		if (scheme.in === "cookie") {
-			const existing = headers.get("Cookie");
-			const part = `${scheme.name}=${globals.apiKey}`;
-			headers.set("Cookie", existing ? `${existing}; ${part}` : part);
-		}
-
-		return { headers, url };
-	}
-
-	return { headers, url };
-}
-
-export type EmbeddedDefaults = {
-	server?: string;
-	serverVars?: string[];
-	auth?: string;
-};
-
-export type BuildRequestInput = {
-	specId: string;
-	action: CommandAction;
-	positionalValues: string[];
-	flagValues: Record<string, unknown>;
-	globals: RuntimeGlobals;
-	servers: import("../server.ts").ServerInfo[];
-	authSchemes: AuthScheme[];
-	embeddedDefaults?: EmbeddedDefaults;
-	bodyFlagDefs?: import("./body-flags.ts").BodyFlagDef[];
-};
-
-export async function buildRequest(
-	input: BuildRequestInput,
-): Promise<{ request: Request; curl: string }> {
-	// Always use the "default" profile for simplicity
-	const defaultProfileName = "default";
-	const profilesFile = await readProfiles();
-	const profile = getProfile(profilesFile, defaultProfileName);
-	const embedded = input.embeddedDefaults;
-
-	// Merge server vars: CLI flags override embedded defaults
-	const embeddedServerVars = parseKeyValuePairs(embedded?.serverVars);
-	const cliServerVars = parseKeyValuePairs(input.globals.serverVar);
-	const serverVars = { ...embeddedServerVars, ...cliServerVars };
-
-	// Priority: CLI flag > profile > embedded default
-	const serverUrl = resolveServerUrl({
-		serverOverride: input.globals.server ?? profile?.server ?? embedded?.server,
-		servers: input.servers,
-		serverVars,
-	});
-
-	// Path params: action.positionals order matches templated params order.
-	const pathVars: Record<string, string> = {};
-	for (let i = 0; i < input.action.positionals.length; i++) {
-		const pos = input.action.positionals[i];
-		const raw = input.action.pathArgs[i];
-		const value = input.positionalValues[i];
-		if (typeof raw === "string" && typeof value === "string") {
-			pathVars[raw] = value;
-		}
-		// Use cli name too as fallback
-		if (pos?.name && typeof value === "string") {
-			pathVars[pos.name] = value;
-		}
-	}
-
-	const path = applyTemplate(input.action.path, pathVars, { encode: true });
-
-	// 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();
-
-	// Collect declared params for validation.
-	const queryValues: Record<string, unknown> = {};
-	const headerValues: Record<string, unknown> = {};
-	const cookieValues: Record<string, unknown> = {};
-
-	for (const p of input.action.params) {
-		if (p.kind !== "flag") continue;
-		const optValue = input.flagValues[optionKeyFromFlag(p.flag)];
-		if (typeof optValue === "undefined") continue;
-
-		if (p.in === "query") {
-			queryValues[p.name] = optValue;
-		}
-		if (p.in === "header") {
-			headerValues[p.name] = optValue;
-		}
-		if (p.in === "cookie") {
-			cookieValues[p.name] = optValue;
-		}
-	}
-
-	// Validate params (query/header/cookie) using Ajv.
-	const schemas = deriveValidationSchemas(input.action);
-	const ajv = createAjv();
-
-	if (schemas.querySchema) {
-		const validate = ajv.compile(schemas.querySchema);
-		if (!validate(queryValues)) {
-			throw new Error(formatAjvErrors(validate.errors));
-		}
-	}
-	if (schemas.headerSchema) {
-		const validate = ajv.compile(schemas.headerSchema);
-		if (!validate(headerValues)) {
-			throw new Error(formatAjvErrors(validate.errors));
-		}
-	}
-	if (schemas.cookieSchema) {
-		const validate = ajv.compile(schemas.cookieSchema);
-		if (!validate(cookieValues)) {
-			throw new Error(formatAjvErrors(validate.errors));
-		}
-	}
-
-	// Apply params -> query/header/cookie
-	for (const [name, value] of Object.entries(queryValues)) {
-		if (Array.isArray(value)) {
-			for (const item of value) {
-				url.searchParams.append(name, String(item));
-			}
-			continue;
-		}
-		url.searchParams.set(name, String(value));
-	}
-	for (const [name, value] of Object.entries(headerValues)) {
-		headers.set(name, String(value));
-	}
-	for (const [name, value] of Object.entries(cookieValues)) {
-		const existing = headers.get("Cookie");
-		const part = `${name}=${String(value)}`;
-		headers.set("Cookie", existing ? `${existing}; ${part}` : part);
-	}
-
-	let body: string | undefined;
-	if (input.action.requestBody) {
-		// Check if any body flags were provided using the flag definitions
-		const bodyFlagDefs = input.bodyFlagDefs ?? [];
-		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;
-		});
-
-		const contentType = input.action.requestBody.preferredContentType;
-		if (contentType) headers.set("Content-Type", contentType);
-
-		const schema = input.action.requestBodySchema;
-
-		// Check if there are any required fields in the body
-		const requiredFields = bodyFlagDefs.filter((d) => d.required);
-
-		if (!hasBodyFlags) {
-			if (requiredFields.length > 0) {
-				// Error: user must provide required fields
-				const flagList = requiredFields.map((d) => `--${d.path.join(".")}`);
-				throw new Error(`Required: ${flagList.join(", ")}`);
-			}
-			// No required fields - send empty body if body is required, otherwise skip
-			if (input.action.requestBody.required) {
-				body = "{}";
-			}
-		} else {
-			if (!contentType?.includes("json")) {
-				throw new Error(
-					"Body field flags are only supported for JSON request bodies.",
-				);
-			}
-
-			// Check for missing required fields
-			const { findMissingRequired, parseDotNotationFlags } = await import(
-				"./body-flags.ts"
-			);
-			const missing = findMissingRequired(input.flagValues, bodyFlagDefs);
-			if (missing.length > 0) {
-				const missingFlags = missing.map((m) => `--${m}`).join(", ");
-				throw new Error(`Missing required fields: ${missingFlags}`);
-			}
-
-			// Build nested object from dot-notation flags
-			const built = parseDotNotationFlags(input.flagValues, bodyFlagDefs);
-
-			if (schema) {
-				const validate = ajv.compile(schema);
-				if (!validate(built)) {
-					throw new Error(formatAjvErrors(validate.errors));
-				}
-			}
-
-			body = JSON.stringify(built);
-		}
-	}
-
-	// Check if user has a stored token (needed for auth scheme auto-selection)
-	const storedToken = profile?.name
-		? await getToken(input.specId, profile.name)
-		: null;
-
-	// Auth resolution priority: CLI flag > profile > embedded default
-	const resolvedAuthScheme = resolveAuthScheme(
-		input.authSchemes,
-		input.action.auth,
-		{
-			flagAuthScheme: input.globals.auth,
-			profileAuthScheme: profile?.authScheme,
-			embeddedAuthScheme: embedded?.auth,
-			hasStoredToken: Boolean(storedToken),
-		},
-	);
-
-	const tokenFromProfile = resolvedAuthScheme ? storedToken : null;
-
-	const globalsWithProfileAuth: RuntimeGlobals = {
-		...input.globals,
-		auth: resolvedAuthScheme,
-		bearerToken:
-			input.globals.bearerToken ??
-			input.globals.oauthToken ??
-			tokenFromProfile ??
-			undefined,
-	};
-
-	const final = applyAuth(
-		headers,
-		url,
-		input.action,
-		globalsWithProfileAuth,
-		input.authSchemes,
-	);
-
-	const req = new Request(final.url.toString(), {
-		method: input.action.method,
-		headers: final.headers,
-		body,
-	});
-
-	const curl = buildCurl(req, body);
-	return { request: req, curl };
-}
-
-function buildCurl(req: Request, body: string | undefined): string {
-	const parts: string[] = ["curl", "-sS", "-X", req.method];
-	for (const [k, v] of req.headers.entries()) {
-		parts.push("-H", shellQuote(`${k}: ${v}`));
-	}
-	if (typeof body === "string") {
-		parts.push("--data", shellQuote(body));
-	}
-	parts.push(shellQuote(req.url));
-	return parts.join(" ");
-}
-
-function shellQuote(value: string): string {
-	return `'${value.replace(/'/g, `'\\''`)}'`;
-}
-
-function optionKeyFromFlag(flag: string): string {
-	// Commander uses camelCase property names derived from long flag.
-	// Example: --x-request-id -> xRequestId
-	const name = flag.replace(/^--/, "");
-	return name.replace(/-([a-z])/g, (_, c) => String(c).toUpperCase());
-}

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

@@ -1,45 +0,0 @@
-import type { ServerInfo } from "../server.ts";
-
-import { applyTemplate, extractTemplateVars } from "./template.ts";
-
-export type ResolveServerInput = {
-	serverOverride?: string;
-	servers: ServerInfo[];
-	serverVars: Record<string, string>;
-};
-
-export function resolveServerUrl(input: ResolveServerInput): string {
-	// 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.",
-		);
-	}
-
-	const names = extractTemplateVars(base);
-	if (!names.length) return base;
-
-	const vars: Record<string, string> = {};
-	for (const name of names) {
-		const provided = input.serverVars[name];
-		if (typeof provided === "string") {
-			vars[name] = provided;
-			continue;
-		}
-
-		// If spec has default for this var, use it.
-		const match = input.servers.find((s) => s.url === base);
-		const v = match?.variables.find((x) => x.name === name);
-		if (typeof v?.default === "string") {
-			vars[name] = v.default;
-			continue;
-		}
-
-		throw new Error(
-			`Missing server variable '${name}'. Provide --server-var ${name}=...`,
-		);
-	}
-
-	return applyTemplate(base, vars);
-}

package/src/cli/runtime/template.ts

@@ -1,26 +0,0 @@
-export function extractTemplateVars(template: string): string[] {
-	const out: string[] = [];
-	const re = /\{([^}]+)\}/g;
-	while (true) {
-		const match = re.exec(template);
-		if (!match) break;
-		out.push((match[1] ?? "").trim());
-	}
-	return out.filter(Boolean);
-}
-
-export function applyTemplate(
-	template: string,
-	vars: Record<string, string>,
-	options?: { encode?: boolean },
-): string {
-	const encode = options?.encode ?? false;
-	return template.replace(/\{([^}]+)\}/g, (_, rawName) => {
-		const name = String(rawName).trim();
-		const value = vars[name];
-		if (typeof value !== "string") {
-			throw new Error(`Missing template variable: ${name}`);
-		}
-		return encode ? encodeURIComponent(value) : value;
-	});
-}

package/src/cli/runtime/validate/ajv.ts

@@ -1,13 +0,0 @@
-import Ajv from "ajv";
-import addFormats from "ajv-formats";
-
-export function createAjv() {
-	const ajv = new Ajv({
-		allErrors: true,
-		strict: false,
-		coerceTypes: false,
-	});
-
-	addFormats(ajv);
-	return ajv;
-}

package/src/cli/runtime/validate/coerce.ts

@@ -1,71 +0,0 @@
-import { InvalidArgumentError } from "commander";
-
-import type { ParamType } from "../../schema-shape.ts";
-
-export function coerceValue(raw: string, type: ParamType): unknown {
-	if (type === "string" || type === "unknown") return raw;
-
-	if (type === "boolean") {
-		// Commander boolean options are handled without a value; keep for completeness.
-		if (raw === "true") return true;
-		if (raw === "false") return false;
-		throw new InvalidArgumentError(`Expected boolean, got '${raw}'`);
-	}
-
-	if (type === "integer") {
-		const n = Number.parseInt(raw, 10);
-		if (!Number.isFinite(n))
-			throw new InvalidArgumentError(`Expected integer, got '${raw}'`);
-		return n;
-	}
-
-	if (type === "number") {
-		const n = Number(raw);
-		if (!Number.isFinite(n))
-			throw new InvalidArgumentError(`Expected number, got '${raw}'`);
-		return n;
-	}
-
-	// For now, accept objects as JSON strings.
-	if (type === "object") {
-		try {
-			return JSON.parse(raw);
-		} catch {
-			throw new InvalidArgumentError(
-				`Expected JSON object, got '${raw}'. Use --data/--file for complex bodies.`,
-			);
-		}
-	}
-
-	// Arrays should usually be passed as repeatable flags or comma-separated,
-	// but allow JSON arrays too.
-	if (type === "array") {
-		return coerceArrayInput(raw, "string");
-	}
-
-	return raw;
-}
-
-export function coerceArrayInput(raw: string, itemType: ParamType): unknown[] {
-	const trimmed = raw.trim();
-	if (!trimmed) return [];
-
-	if (trimmed.startsWith("[")) {
-		let parsed: unknown;
-		try {
-			parsed = JSON.parse(trimmed);
-		} catch {
-			throw new InvalidArgumentError(`Expected JSON array, got '${raw}'`);
-		}
-		if (!Array.isArray(parsed)) {
-			throw new InvalidArgumentError(`Expected JSON array, got '${raw}'`);
-		}
-		return parsed.map((v) => coerceValue(String(v), itemType));
-	}
-
-	return trimmed
-		.split(",")
-		.map((s) => s.trim())
-		.filter(Boolean)
-		.map((s) => coerceValue(s, itemType));
-}

package/src/cli/runtime/validate/error.ts

@@ -1,29 +0,0 @@
-import type { ErrorObject } from "ajv";
-
-export function formatAjvErrors(
-	errors: ErrorObject[] | null | undefined,
-): string {
-	if (!errors?.length) return "Invalid input";
-
-	return errors
-		.map((e) => {
-			const path = e.instancePath || e.schemaPath || "";
-
-			if (
-				e.keyword === "required" &&
-				e.params &&
-				typeof e.params === "object" &&
-				"missingProperty" in e.params
-			) {
-				const missing = String(
-					(e.params as { missingProperty?: unknown }).missingProperty,
-				);
-				const where = e.instancePath || "/";
-				return `${where} missing required property '${missing}'`.trim();
-			}
-
-			const msg = e.message || "invalid";
-			return `${path} ${msg}`.trim();
-		})
-		.join("\n");
-}

package/src/cli/runtime/validate/index.ts

@@ -1,4 +0,0 @@
-export * from "./ajv.ts";
-export * from "./coerce.ts";
-export * from "./error.ts";
-export * from "./schema.ts";

package/src/cli/runtime/validate/schema.ts

@@ -1,54 +0,0 @@
-import type { CommandAction } from "../../command-model.ts";
-import type { JsonSchema } from "../../types.ts";
-
-export type ValidationSchemas = {
-	querySchema?: JsonSchema;
-	headerSchema?: JsonSchema;
-	cookieSchema?: JsonSchema;
-};
-
-type ObjectSchema = {
-	type: "object";
-	properties: Record<string, JsonSchema>;
-	required?: string[];
-};
-
-export function deriveValidationSchemas(
-	action: CommandAction,
-): ValidationSchemas {
-	// We validate only simple containers for now.
-	// Deep style/encoding differences for OpenAPI params are out of scope for v1.
-	const query: ObjectSchema = { type: "object", properties: {}, required: [] };
-	const header: ObjectSchema = { type: "object", properties: {}, required: [] };
-	const cookie: ObjectSchema = { type: "object", properties: {}, required: [] };
-
-	for (const p of action.params) {
-		if (p.kind !== "flag") continue;
-		const target =
-			p.in === "query"
-				? query
-				: p.in === "header"
-					? header
-					: p.in === "cookie"
-						? cookie
-						: undefined;
-		if (!target) continue;
-
-		const schema = p.schema ?? (p.type === "unknown" ? {} : { type: p.type });
-		target.properties[p.name] = schema;
-		if (p.required) {
-			if (!target.required) target.required = [];
-			target.required.push(p.name);
-		}
-	}
-
-	if (!query.required?.length) delete query.required;
-	if (!header.required?.length) delete header.required;
-	if (!cookie.required?.length) delete cookie.required;
-
-	return {
-		querySchema: Object.keys(query.properties).length ? query : undefined,
-		headerSchema: Object.keys(header.properties).length ? header : undefined,
-		cookieSchema: Object.keys(cookie.properties).length ? cookie : undefined,
-	};
-}

package/src/cli/schema-shape.ts

@@ -1,36 +0,0 @@
-export type ParamType =
-	| "string"
-	| "number"
-	| "integer"
-	| "boolean"
-	| "array"
-	| "object"
-	| "unknown";
-
-export function getSchemaType(schema: unknown): ParamType {
-	if (!schema || typeof schema !== "object") return "unknown";
-	const t = (schema as { type?: unknown }).type;
-	if (t === "string") return "string";
-	if (t === "number") return "number";
-	if (t === "integer") return "integer";
-	if (t === "boolean") return "boolean";
-	if (t === "array") return "array";
-	if (t === "object") return "object";
-	return "unknown";
-}
-
-export function getSchemaFormat(schema: unknown): string | undefined {
-	if (!schema || typeof schema !== "object") return undefined;
-	const f = (schema as { format?: unknown }).format;
-	return typeof f === "string" ? f : undefined;
-}
-
-export function getSchemaEnumStrings(schema: unknown): string[] | undefined {
-	if (!schema || typeof schema !== "object") return undefined;
-	const e = (schema as { enum?: unknown }).enum;
-	if (!Array.isArray(e)) return undefined;
-
-	// We only surface string enums for now (enough for flag docs + completion).
-	const values = e.filter((v) => typeof v === "string") as string[];
-	return values.length ? values : undefined;
-}