specli 0.0.1

package/src/cli/compile.ts

@@ -0,0 +1,119 @@
+import { deriveBinaryName } from "./derive-name.ts";
+
+export type CompileOptions = {
+	name?: string;
+	outfile?: string;
+	target?: string;
+	minify?: boolean;
+	bytecode?: boolean;
+	dotenv?: boolean; // --no-dotenv sets this to false
+	bunfig?: boolean; // --no-bunfig sets this to false
+	execArgv?: string[];
+	define?: string[];
+	server?: string;
+	serverVar?: string[];
+	auth?: string;
+};
+
+function parseKeyValue(input: string): { key: string; value: string } {
+	const idx = input.indexOf("=");
+	if (idx === -1)
+		throw new Error(`Invalid --define '${input}', expected key=value`);
+	const key = input.slice(0, idx).trim();
+	const value = input.slice(idx + 1).trim();
+	if (!key) throw new Error(`Invalid --define '${input}', missing key`);
+	return { key, value };
+}
+
+export async function compileCommand(
+	spec: string,
+	options: CompileOptions,
+): Promise<void> {
+	// Derive name from spec if not provided
+	const name = options.name ?? (await deriveBinaryName(spec));
+	const outfile = options.outfile ?? `./dist/${name}`;
+
+	const target = options.target
+		? (options.target as Bun.Build.Target)
+		: (`bun-${process.platform}-${process.arch}` as Bun.Build.Target);
+
+	// Build embedded execArgv for runtime defaults
+	const embeddedExecArgv: string[] = [];
+	if (options.server) {
+		embeddedExecArgv.push(`--server=${options.server}`);
+	}
+	if (options.serverVar) {
+		for (const pair of options.serverVar) {
+			embeddedExecArgv.push(`--server-var=${pair}`);
+		}
+	}
+	if (options.auth) {
+		embeddedExecArgv.push(`--auth=${options.auth}`);
+	}
+
+	// User-provided exec-argv
+	const compileExecArgv = options.execArgv ?? [];
+
+	// Parse --define pairs
+	const define: Record<string, string> = {};
+	if (options.define) {
+		for (const pair of options.define) {
+			const { key, value } = parseKeyValue(pair);
+			define[key] = JSON.stringify(value);
+		}
+	}
+
+	// Build command args
+	const buildArgs = [
+		"build",
+		"--compile",
+		`--outfile=${outfile}`,
+		`--target=${target}`,
+	];
+
+	if (options.minify) buildArgs.push("--minify");
+	if (options.bytecode) buildArgs.push("--bytecode");
+
+	for (const [k, v] of Object.entries(define)) {
+		buildArgs.push("--define", `${k}=${v}`);
+	}
+
+	const execArgv =
+		embeddedExecArgv.length || compileExecArgv.length
+			? [...embeddedExecArgv, ...compileExecArgv]
+			: [];
+	for (const arg of execArgv) {
+		buildArgs.push("--compile-exec-argv", arg);
+	}
+
+	if (options.dotenv === false) buildArgs.push("--no-compile-autoload-dotenv");
+	if (options.bunfig === false) buildArgs.push("--no-compile-autoload-bunfig");
+
+	buildArgs.push("./src/compiled.ts");
+
+	const proc = Bun.spawn({
+		cmd: ["bun", ...buildArgs],
+		stdout: "pipe",
+		stderr: "pipe",
+		env: {
+			...process.env,
+			OPENCLI_EMBED_SPEC: spec,
+			OPENCLI_CLI_NAME: name,
+		},
+	});
+
+	const output = await new Response(proc.stdout).text();
+	const error = await new Response(proc.stderr).text();
+	const code = await proc.exited;
+
+	if (output) process.stdout.write(output);
+	if (error) process.stderr.write(error);
+	if (code !== 0) {
+		process.exitCode = code;
+		return;
+	}
+
+	process.stdout.write(`ok: built ${outfile}\n`);
+	process.stdout.write(`target: ${target}\n`);
+	process.stdout.write(`name: ${name}\n`);
+}

package/src/cli/crypto.ts

@@ -0,0 +1,9 @@
+export async function sha256Hex(text: string): Promise<string> {
+	const data = new TextEncoder().encode(text);
+	const hash = await crypto.subtle.digest("SHA-256", data);
+	const bytes = new Uint8Array(hash);
+
+	let out = "";
+	for (const b of bytes) out += b.toString(16).padStart(2, "0");
+	return out;
+}

package/src/cli/derive-name.ts

@@ -0,0 +1,101 @@
+const RESERVED_NAMES = [
+	"exec",
+	"compile",
+	"profile",
+	"auth",
+	"help",
+	"version",
+];
+
+/**
+ * Derives a clean binary name from an OpenAPI spec.
+ * Priority:
+ *   1. info.title (kebab-cased, sanitized)
+ *   2. Host from spec URL (if URL provided)
+ *   3. Fallback to "opencli"
+ */
+export async function deriveBinaryName(spec: string): Promise<string> {
+	try {
+		// Load spec to extract title
+		const text = await loadSpecText(spec);
+		const doc = parseSpec(text);
+
+		const title = doc?.info?.title;
+		if (title && typeof title === "string") {
+			const name = sanitizeName(title);
+			if (name) return name;
+		}
+	} catch {
+		// Fall through to URL-based derivation
+	}
+
+	// Try to derive from URL host
+	if (/^https?:\/\//i.test(spec)) {
+		try {
+			const url = new URL(spec);
+			const hostParts = url.hostname.split(".");
+			// Use first meaningful segment (skip www, api prefixes)
+			const meaningful = hostParts.find(
+				(p) => p !== "www" && p !== "api" && p.length > 2,
+			);
+			if (meaningful) {
+				const name = sanitizeName(meaningful);
+				if (name) return name;
+			}
+		} catch {
+			// Invalid URL, fall through
+		}
+	}
+
+	// Fallback
+	return "opencli";
+}
+
+async function loadSpecText(spec: string): Promise<string> {
+	if (/^https?:\/\//i.test(spec)) {
+		const res = await fetch(spec);
+		if (!res.ok) throw new Error(`Failed to fetch: ${res.status}`);
+		return res.text();
+	}
+	return Bun.file(spec).text();
+}
+
+function parseSpec(text: string): { info?: { title?: string } } | null {
+	try {
+		const trimmed = text.trimStart();
+		if (trimmed.startsWith("{") || trimmed.startsWith("[")) {
+			return JSON.parse(text);
+		}
+		// Use Bun's YAML parser
+		const { YAML } = globalThis.Bun ?? {};
+		if (YAML?.parse) {
+			return YAML.parse(text) as { info?: { title?: string } };
+		}
+		// Fallback: only JSON supported
+		return null;
+	} catch {
+		return null;
+	}
+}
+
+/**
+ * Convert title to valid binary name:
+ * - kebab-case
+ * - lowercase
+ * - remove invalid chars
+ * - max 32 chars
+ * - avoid reserved names
+ */
+function sanitizeName(input: string): string {
+	let name = input
+		.toLowerCase()
+		.replace(/[^a-z0-9]+/g, "-") // Replace non-alphanumeric with dash
+		.replace(/^-+|-+$/g, "") // Trim leading/trailing dashes
+		.slice(0, 32); // Limit length
+
+	if (RESERVED_NAMES.includes(name)) {
+		name = `${name}-cli`;
+	}
+
+	return name;
+}

package/src/cli/exec.ts

@@ -0,0 +1,72 @@
+import { main } from "./main.ts";
+
+export type ExecOptions = {
+	server?: string;
+	serverVar?: string[];
+	auth?: string;
+	bearerToken?: string;
+	oauthToken?: string;
+	username?: string;
+	password?: string;
+	apiKey?: string;
+	profile?: string;
+	json?: boolean;
+};
+
+export async function execCommand(
+	spec: string,
+	options: ExecOptions,
+	commandArgs: string[],
+): Promise<void> {
+	// commandArgs includes the spec as first element, filter it out
+	// to get the remaining args (resource, action, etc.)
+	const remainingArgs = commandArgs.slice(1);
+
+	// Reconstruct argv for main():
+	// [node, script, --spec, <spec>, ...options, ...remainingArgs]
+	const argv = [
+		process.argv[0] ?? "bun",
+		process.argv[1] ?? "opencli",
+		"--spec",
+		spec,
+	];
+
+	// Add common options back as flags
+	if (options.server) {
+		argv.push("--server", options.server);
+	}
+	if (options.serverVar) {
+		for (const v of options.serverVar) {
+			argv.push("--server-var", v);
+		}
+	}
+	if (options.auth) {
+		argv.push("--auth", options.auth);
+	}
+	if (options.bearerToken) {
+		argv.push("--bearer-token", options.bearerToken);
+	}
+	if (options.oauthToken) {
+		argv.push("--oauth-token", options.oauthToken);
+	}
+	if (options.username) {
+		argv.push("--username", options.username);
+	}
+	if (options.password) {
+		argv.push("--password", options.password);
+	}
+	if (options.apiKey) {
+		argv.push("--api-key", options.apiKey);
+	}
+	if (options.profile) {
+		argv.push("--profile", options.profile);
+	}
+	if (options.json) {
+		argv.push("--json");
+	}
+
+	// Append remaining args (subcommand + its args)
+	argv.push(...remainingArgs);
+
+	await main(argv);
+}

package/src/cli/main.ts

@@ -0,0 +1,336 @@
+import { Command } from "commander";
+
+import { getArgValue, hasAnyArg } from "./runtime/argv.ts";
+import { collectRepeatable } from "./runtime/collect.ts";
+import { buildRuntimeContext } from "./runtime/context.ts";
+import { addGeneratedCommands } from "./runtime/generated.ts";
+import { deleteToken, getToken, setToken } from "./runtime/profile/secrets.ts";
+import {
+	getProfile,
+	readProfiles,
+	removeProfile,
+	upsertProfile,
+	writeProfiles,
+} from "./runtime/profile/store.ts";
+import { toMinimalSchemaOutput } from "./schema.ts";
+import { stableStringify } from "./stable-json.ts";
+
+type MainOptions = {
+	embeddedSpecText?: string;
+	cliName?: string;
+};
+
+export async function main(argv: string[], options: MainOptions = {}) {
+	const program = new Command();
+
+	program
+		.name(options.cliName ?? "opencli")
+		.description("Generate a CLI from an OpenAPI spec")
+		.option("--spec <urlOrPath>", "OpenAPI URL or file path")
+		.option("--server <url>", "Override server/base URL")
+		.option(
+			"--server-var <name=value>",
+			"Server URL template variable (repeatable)",
+			collectRepeatable,
+		)
+		.option("--auth <scheme>", "Select auth scheme by key")
+		.option("--bearer-token <token>", "Bearer token (Authorization: Bearer)")
+		.option("--oauth-token <token>", "OAuth token (alias of bearer)")
+		.option("--username <username>", "Basic auth username")
+		.option("--password <password>", "Basic auth password")
+		.option("--api-key <key>", "API key value")
+		.option("--profile <name>", "Profile name (stored under ~/.config/opencli)")
+		.option("--json", "Machine-readable output")
+		.showHelpAfterError();
+
+	// Provide namespaced variants for flags which may collide with operation flags.
+	// (Some real-world APIs define parameters named "accept", etc.)
+	program
+		.option(
+			"--oc-header <header>",
+			"Extra header (repeatable, namespaced)",
+			collectRepeatable,
+		)
+		.option("--oc-accept <type>", "Override Accept header (namespaced)")
+		.option("--oc-status", "Include status in --json output (namespaced)")
+		.option("--oc-headers", "Include headers in --json output (namespaced)")
+		.option("--oc-dry-run", "Print request without sending (namespaced)")
+		.option("--oc-curl", "Print curl command without sending (namespaced)")
+		.option("--oc-timeout <ms>", "Request timeout in milliseconds (namespaced)")
+		.option("--oc-data <data>", "Inline request body (namespaced)")
+		.option("--oc-file <path>", "Request body from file (namespaced)")
+		.option(
+			"--oc-content-type <type>",
+			"Override Content-Type (defaults from OpenAPI) (namespaced)",
+		);
+
+	// If user asks for help and we have no embedded spec and no --spec, show minimal help.
+	const spec = getArgValue(argv, "--spec");
+	const wantsHelp = hasAnyArg(argv, ["-h", "--help"]);
+	if (!spec && !options.embeddedSpecText && wantsHelp) {
+		program.addHelpText(
+			"after",
+			"\nTo see generated commands, run with --spec <url|path>.\n",
+		);
+		program.parse(argv);
+		return;
+	}
+
+	const ctx = await buildRuntimeContext({
+		spec,
+		embeddedSpecText: options.embeddedSpecText,
+	});
+
+	const profileCmd = program
+		.command("profile")
+		.description("Manage OpenCLI profiles");
+
+	profileCmd
+		.command("list")
+		.description("List profiles")
+		.action(async (_opts, command) => {
+			const globals = command.optsWithGlobals() as { json?: boolean };
+			const file = await readProfiles();
+
+			const payload = {
+				defaultProfile: file.defaultProfile,
+				profiles: file.profiles.map((p) => ({
+					name: p.name,
+					server: p.server,
+					authScheme: p.authScheme,
+				})),
+			};
+
+			if (globals.json) {
+				process.stdout.write(`${JSON.stringify(payload)}\n`);
+				return;
+			}
+
+			if (payload.defaultProfile) {
+				process.stdout.write(`default: ${payload.defaultProfile}\n`);
+			}
+			for (const p of payload.profiles) {
+				process.stdout.write(`${p.name}\n`);
+				if (p.server) process.stdout.write(`  server: ${p.server}\n`);
+				if (p.authScheme)
+					process.stdout.write(`  authScheme: ${p.authScheme}\n`);
+			}
+		});
+
+	profileCmd
+		.command("set")
+		.description("Create or update a profile")
+		.requiredOption("--name <name>", "Profile name")
+		.option("--server <url>", "Default server/base URL")
+		.option("--auth <scheme>", "Default auth scheme key")
+		.option("--default", "Set as default profile")
+		.action(async (opts, command) => {
+			const globals = command.optsWithGlobals() as {
+				json?: boolean;
+				server?: string;
+				auth?: string;
+			};
+
+			const file = await readProfiles();
+			const next = upsertProfile(file, {
+				name: String(opts.name),
+				server:
+					typeof opts.server === "string"
+						? opts.server
+						: typeof globals.server === "string"
+							? globals.server
+							: undefined,
+				authScheme:
+					typeof opts.auth === "string"
+						? opts.auth
+						: typeof globals.auth === "string"
+							? globals.auth
+							: undefined,
+			});
+			const final = opts.default
+				? { ...next, defaultProfile: String(opts.name) }
+				: next;
+			await writeProfiles(final);
+
+			if (globals.json) {
+				process.stdout.write(
+					`${JSON.stringify({ ok: true, profile: String(opts.name) })}\n`,
+				);
+				return;
+			}
+			process.stdout.write(`ok: profile ${String(opts.name)}\n`);
+		});
+
+	profileCmd
+		.command("rm")
+		.description("Remove a profile")
+		.requiredOption("--name <name>", "Profile name")
+		.action(async (opts, command) => {
+			const globals = command.optsWithGlobals() as { json?: boolean };
+			const file = await readProfiles();
+			const removed = removeProfile(file, String(opts.name));
+
+			const final =
+				file.defaultProfile === opts.name
+					? { ...removed, defaultProfile: undefined }
+					: removed;
+
+			await writeProfiles(final);
+
+			if (globals.json) {
+				process.stdout.write(
+					`${JSON.stringify({ ok: true, profile: String(opts.name) })}\n`,
+				);
+				return;
+			}
+
+			process.stdout.write(`ok: removed ${String(opts.name)}\n`);
+		});
+
+	profileCmd
+		.command("use")
+		.description("Set the default profile")
+		.requiredOption("--name <name>", "Profile name")
+		.action(async (opts, command) => {
+			const globals = command.optsWithGlobals() as { json?: boolean };
+			const file = await readProfiles();
+			const profile = getProfile(file, String(opts.name));
+			if (!profile) throw new Error(`Profile not found: ${String(opts.name)}`);
+
+			await writeProfiles({ ...file, defaultProfile: String(opts.name) });
+
+			if (globals.json) {
+				process.stdout.write(
+					`${JSON.stringify({ ok: true, defaultProfile: String(opts.name) })}\n`,
+				);
+				return;
+			}
+			process.stdout.write(`ok: default ${String(opts.name)}\n`);
+		});
+
+	const authCmd = program.command("auth").description("Manage auth secrets");
+
+	authCmd
+		.command("token")
+		.description("Set or get bearer token for a profile")
+		.option("--name <name>", "Profile name (defaults to global --profile)")
+		.option("--set <token>", "Set token")
+		.option("--get", "Get token")
+		.option("--delete", "Delete token")
+		.action(async (opts, command) => {
+			const globals = command.optsWithGlobals() as {
+				json?: boolean;
+				profile?: string;
+			};
+
+			const profileName = String(opts.name ?? globals.profile ?? "");
+			if (!profileName) {
+				throw new Error(
+					"Missing profile name. Provide --name <name> or global --profile <name>.",
+				);
+			}
+			if (opts.set && (opts.get || opts.delete)) {
+				throw new Error("Use only one of --set, --get, --delete");
+			}
+			if (opts.get && opts.delete) {
+				throw new Error("Use only one of --get or --delete");
+			}
+			if (!opts.set && !opts.get && !opts.delete) {
+				throw new Error("Provide one of --set, --get, --delete");
+			}
+
+			if (typeof opts.set === "string") {
+				await setToken(ctx.loaded.id, profileName, opts.set);
+				if (globals.json) {
+					process.stdout.write(
+						`${JSON.stringify({ ok: true, profile: profileName })}\n`,
+					);
+					return;
+				}
+				process.stdout.write(`ok: token set for ${profileName}\n`);
+				return;
+			}
+
+			if (opts.get) {
+				const token = await getToken(ctx.loaded.id, profileName);
+				if (globals.json) {
+					process.stdout.write(
+						`${JSON.stringify({ profile: profileName, token })}\n`,
+					);
+					return;
+				}
+				process.stdout.write(`${token ?? ""}\n`);
+				return;
+			}
+
+			if (opts.delete) {
+				const ok = await deleteToken(ctx.loaded.id, profileName);
+				if (globals.json) {
+					process.stdout.write(
+						`${JSON.stringify({ ok, profile: profileName })}\n`,
+					);
+					return;
+				}
+				process.stdout.write(`ok: ${ok ? "deleted" : "not-found"}\n`);
+			}
+		});
+
+	program
+		.command("__schema")
+		.description("Print indexed operations (machine-readable when --json)")
+		.option("--pretty", "Pretty-print JSON when used with --json")
+		.option("--min", "Minimal JSON output (commands + metadata only)")
+		.action(async (_opts, command) => {
+			const flags = command.optsWithGlobals() as {
+				json?: boolean;
+				pretty?: boolean;
+				min?: boolean;
+			};
+
+			if (flags.json) {
+				const pretty = Boolean(flags.pretty);
+				const payload = flags.min
+					? toMinimalSchemaOutput(ctx.schema)
+					: ctx.schema;
+				const text = stableStringify(payload, { space: pretty ? 2 : 0 });
+				process.stdout.write(`${text}\n`);
+				return;
+			}
+
+			process.stdout.write(`${ctx.schema.openapi.title ?? "(untitled)"}\n`);
+			process.stdout.write(`OpenAPI: ${ctx.schema.openapi.version}\n`);
+			process.stdout.write(
+				`Spec: ${ctx.schema.spec.id} (${ctx.schema.spec.source})\n`,
+			);
+			process.stdout.write(`Fingerprint: ${ctx.schema.spec.fingerprint}\n`);
+			process.stdout.write(`Servers: ${ctx.schema.servers.length}\n`);
+			process.stdout.write(`Auth Schemes: ${ctx.schema.authSchemes.length}\n`);
+			process.stdout.write(`Operations: ${ctx.schema.operations.length}\n`);
+
+			for (const op of ctx.schema.operations) {
+				const id = op.operationId ? ` (${op.operationId})` : "";
+				process.stdout.write(`- ${op.method} ${op.path}${id}\n`);
+			}
+
+			if (ctx.schema.planned?.length) {
+				process.stdout.write("\nPlanned commands:\n");
+				for (const op of ctx.schema.planned) {
+					const args = op.pathArgs.length
+						? ` ${op.pathArgs.map((a) => `<${a}>`).join(" ")}`
+						: "";
+					process.stdout.write(
+						`- opencli ${op.resource} ${op.action}${args}\n`,
+					);
+				}
+			}
+		});
+
+	addGeneratedCommands(program, {
+		servers: ctx.servers,
+		authSchemes: ctx.authSchemes,
+		commands: ctx.commands,
+		specId: ctx.loaded.id,
+	});
+
+	await program.parseAsync(argv);
+}