@camox/cli 0.14.2 → 0.15.1

package/dist/{api-QINint5w.mjs → api-Bgstxixw.mjs}

@@ -9,10 +9,12 @@ function authHeaders(token) {
 		"Content-Type": "application/json"
 	};
 }
-function createRpcClient(token) {
+function createRpcClient(token, apiUrl = CAMOX_API_URL, environmentName) {
+	const headers = { Authorization: `Bearer ${token}` };
+	if (environmentName) headers["x-environment-name"] = environmentName;
 	return createORPCClient(new RPCLink({
-		url: `${CAMOX_API_URL}/rpc`,
-		headers: { Authorization: `Bearer ${token}` }
+		url: `${apiUrl}/rpc`,
+		headers
 	}));
 }
 async function verifySession(token) {
@@ -62,5 +64,15 @@ async function createProject(token, name, slug, organizationId) {
 		organizationId
 	});
 }
+async function getProjectBySlug(token, slug, apiUrl) {
+	return createRpcClient(token, apiUrl).projects.getBySlug({ slug });
+}
+async function callTool(params) {
+	return await createRpcClient(params.token, params.apiUrl, params.environmentName).agent.callTool({
+		projectId: params.projectId,
+		name: params.name,
+		arguments: params.args
+	});
+}
 //#endregion
-export { setActiveOrganization as a, listOrganizations as i, createOrganization as n, verifySession as o, createProject as r, checkSlugAvailability as t };
+export { getProjectBySlug as a, verifySession as c, createProject as i, checkSlugAvailability as n, listOrganizations as o, createOrganization as r, setActiveOrganization as s, callTool as t };

package/dist/api-DoFRj7vC.mjs

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+import { c as verifySession } from "./api-Bgstxixw.mjs";
+export { verifySession };

package/dist/index.mjs

@@ -1,31 +1,22 @@
 #!/usr/bin/env node
-import { a as setActiveOrganization, i as listOrganizations, n as createOrganization, r as createProject, t as checkSlugAvailability } from "./api-QINint5w.mjs";
+import { a as getProjectBySlug, i as createProject, n as checkSlugAvailability, o as listOrganizations, r as createOrganization, s as setActiveOrganization, t as callTool } from "./api-Bgstxixw.mjs";
 import { object, or } from "@optique/core/constructs";
 import { message } from "@optique/core/message";
 import { defineProgram } from "@optique/core/program";
-import { run } from "@optique/run";
+import { runSync } from "@optique/run";
+import { multiple, optional } from "@optique/core/modifiers";
+import { command, constant, option } from "@optique/core/primitives";
+import { integer, string } from "@optique/core/valueparser";
 import { execSync, spawn, spawnSync } from "node:child_process";
 import fs from "node:fs";
+import http from "node:http";
+import os from "node:os";
 import path from "node:path";
-import { fileURLToPath } from "node:url";
 import * as p from "@clack/prompts";
 import { log } from "@clack/prompts";
-import { command, constant } from "@optique/core/primitives";
+import { ZodError, z } from "zod";
+import { fileURLToPath } from "node:url";
 import slugify from "slugify";
-import http from "node:http";
-import os from "node:os";
-//#region \0rolldown/runtime.js
-var __defProp = Object.defineProperty;
-var __exportAll = (all, no_symbols) => {
-	let target = {};
-	for (var name in all) __defProp(target, name, {
-		get: all[name],
-		enumerable: true
-	});
-	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
-	return target;
-};
-//#endregion
 //#region src/lib/auth.ts
 const CAMOX_URL = process.env.CAMOX_URL || "https://camox.ai";
 const CAMOX_API_URL = process.env.CAMOX_API_URL || "https://api.camox.ai";
@@ -47,7 +38,15 @@ function writeAllTokens(tokens) {
 	fs.writeFileSync(AUTH_FILE, JSON.stringify(tokens, null, 2), { mode: 384 });
 }
 function readAuthToken() {
-	const entry = readAllTokens()[normalizeUrl(CAMOX_URL)];
+	return readAuthTokenForUrl(CAMOX_URL);
+}
+/**
+* Look up a stored token by an explicit auth URL. Used by the tool dispatch
+* path, which sources the URL from the vite plugin sidecar rather than env
+* vars so the right credential is selected per project.
+*/
+function readAuthTokenForUrl(authenticationUrl) {
+	const entry = readAllTokens()[normalizeUrl(authenticationUrl)];
 	if (entry?.token && entry?.name) return entry;
 	return null;
 }
@@ -174,7 +173,7 @@ async function authenticateUser() {
 async function getOrAuthenticate() {
 	const stored = readAuthToken();
 	if (stored) {
-		const { verifySession } = await import("./api-CB7vjDU7.mjs");
+		const { verifySession } = await import("./api-DoFRj7vC.mjs");
 		if (await verifySession(stored.token)) {
 			p.log.info(`Authenticated as ${stored.name}`);
 			return stored;
@@ -185,6 +184,306 @@ async function getOrAuthenticate() {
 	return authenticateUser();
 }
 //#endregion
+//#region src/lib/output.ts
+function isJsonMode(mode) {
+	if (mode === "json") return true;
+	return !process.stdout.isTTY;
+}
+function printResult(value, mode) {
+	const indent = isJsonMode(mode) ? 0 : 2;
+	process.stdout.write(`${JSON.stringify(value, null, indent)}\n`);
+}
+function printError(err) {
+	process.stderr.write(`${JSON.stringify(err)}\n`);
+}
+/**
+* Parse a JSON flag value, surfacing a structured CLI error if the input
+* isn't valid JSON. Block `content` and `settings` arrive this way.
+*/
+function parseJsonFlag(name, raw) {
+	try {
+		return JSON.parse(raw);
+	} catch (e) {
+		const message = e instanceof Error ? e.message : String(e);
+		throw Object.assign(/* @__PURE__ */ new Error(`Invalid JSON for ${name}: ${message}`), { __cliError: {
+			code: "INVALID_JSON",
+			message: `Invalid JSON for ${name}`,
+			details: message
+		} });
+	}
+}
+function asCliError(err) {
+	if (err && typeof err === "object" && "__cliError" in err) return err.__cliError;
+	if (err instanceof Error) return {
+		code: "INTERNAL_ERROR",
+		message: err.message
+	};
+	return {
+		code: "INTERNAL_ERROR",
+		message: String(err)
+	};
+}
+//#endregion
+//#region src/lib/runtime.ts
+/**
+* Subset of the camox vite plugin's options that the CLI needs at dispatch
+* time. Written by the plugin to `node_modules/.camox/runtime.json` on every
+* `configResolved` (dev + build), so it always reflects what vite actually
+* loaded — including `_internal.apiUrl` overrides.
+*
+* Schema is the source of truth; the TS type is derived from it via
+* `z.infer` so the two never drift.
+*/
+const runtimeSchema = z.object({
+	projectSlug: z.string().min(1),
+	apiUrl: z.string().url(),
+	authenticationUrl: z.string().url(),
+	environmentName: z.string().min(1)
+});
+const SIDECAR = path.join("node_modules", ".camox", "runtime.json");
+var RuntimeNotFoundError = class extends Error {
+	cwd;
+	constructor(cwd) {
+		super(`No camox runtime found. Looked for "${SIDECAR}" walking up from ${cwd}. The camox vite plugin writes this file on dev/build — start your project's dev server (or run a build) once before invoking camox.`);
+		this.cwd = cwd;
+		this.name = "RuntimeNotFoundError";
+	}
+};
+var RuntimeMalformedError = class extends Error {
+	constructor(file, reason) {
+		super(`Camox runtime sidecar at ${file} is malformed (${reason}). Re-run your project's dev server to regenerate it.`);
+		this.name = "RuntimeMalformedError";
+	}
+};
+/**
+* Walk up from cwd looking for the sidecar. Validates against `runtimeSchema`
+* and throws `RuntimeNotFoundError` / `RuntimeMalformedError` with messages
+* that tell the user how to fix it.
+*/
+function loadRuntime(cwd = process.cwd()) {
+	let dir = cwd;
+	while (true) {
+		const candidate = path.join(dir, SIDECAR);
+		if (fs.existsSync(candidate)) {
+			let raw;
+			try {
+				raw = JSON.parse(fs.readFileSync(candidate, "utf-8"));
+			} catch (e) {
+				throw new RuntimeMalformedError(candidate, e instanceof Error ? e.message : String(e));
+			}
+			try {
+				return runtimeSchema.parse(raw);
+			} catch (e) {
+				if (e instanceof ZodError) throw new RuntimeMalformedError(candidate, e.issues.map((i) => `${i.path.join(".") || "<root>"}: ${i.message}`).join("; "));
+				throw e;
+			}
+		}
+		const parent = path.dirname(dir);
+		if (parent === dir) throw new RuntimeNotFoundError(cwd);
+		dir = parent;
+	}
+}
+//#endregion
+//#region src/lib/dispatch.ts
+/**
+* Strip undefined fields. Optique returns `undefined` for absent optional
+* flags, but the tool's Zod input often distinguishes `key: undefined` from
+* the key being absent. Send only the keys the user actually passed.
+*/
+function compact(input) {
+	const out = {};
+	for (const [k, v] of Object.entries(input)) if (v !== void 0) out[k] = v;
+	return out;
+}
+function fail(err, code) {
+	printError(err);
+	process.exit(code);
+}
+async function resolveProjectId(token, slug, apiUrl) {
+	try {
+		return (await getProjectBySlug(token, slug, apiUrl)).id;
+	} catch (err) {
+		return fail({
+			code: "PROJECT_LOOKUP_FAILED",
+			message: `Could not load project "${slug}".`,
+			details: err instanceof Error ? err.message : String(err)
+		}, 2);
+	}
+}
+async function callRemote(params) {
+	try {
+		return await callTool(params);
+	} catch (err) {
+		return fail(asCliError(err), 1);
+	}
+}
+/**
+* Resolve auth + project, call the registered tool via `agent.callTool`,
+* and render the result. Exit codes: 0 on success, 1 on tool error, 2 on
+* auth/project resolution failure.
+*
+* Project, apiUrl, and authenticationUrl all come from the vite plugin's
+* `node_modules/.camox/runtime.json` sidecar — that's the single source of
+* truth. `--project <slug>` and `CAMOX_PROJECT` may override the slug.
+*/
+async function dispatch(opts) {
+	let runtime;
+	try {
+		runtime = loadRuntime();
+	} catch (err) {
+		if (err instanceof RuntimeNotFoundError || err instanceof RuntimeMalformedError) return fail({
+			code: "RUNTIME_NOT_FOUND",
+			message: err.message
+		}, 2);
+		throw err;
+	}
+	const slug = opts.projectFlag?.trim() || process.env.CAMOX_PROJECT?.trim() || runtime.projectSlug;
+	const token = readAuthTokenForUrl(runtime.authenticationUrl);
+	if (!token) return fail({
+		code: "NOT_AUTHENTICATED",
+		message: `No stored credentials for ${runtime.authenticationUrl}. Run \`camox login\` against this backend first.`
+	}, 2);
+	const environmentName = opts.production ? "production" : runtime.environmentName;
+	const projectId = await resolveProjectId(token.token, slug, runtime.apiUrl);
+	const response = await callRemote({
+		token: token.token,
+		apiUrl: runtime.apiUrl,
+		environmentName,
+		projectId,
+		name: opts.toolName,
+		args: compact(opts.args)
+	});
+	if (!response.ok) {
+		printError(response.error);
+		process.exit(1);
+	}
+	printResult(response.result, opts.outputMode);
+	process.exit(0);
+}
+//#endregion
+//#region src/commands/blocks.ts
+const projectFlag$2 = optional(option("--project", string({ metavar: "SLUG" })));
+const jsonFlag$2 = option("--json");
+const productionFlag$2 = option("--production");
+const parser$6 = command("blocks", or(command("types", object({
+	command: constant("blocks.types"),
+	project: projectFlag$2,
+	production: productionFlag$2,
+	json: jsonFlag$2
+})), command("describe", object({
+	command: constant("blocks.describe"),
+	type: multiple(option("--type", string({ metavar: "TYPE" })), { min: 1 }),
+	project: projectFlag$2,
+	production: productionFlag$2,
+	json: jsonFlag$2
+})), command("create", object({
+	command: constant("blocks.create"),
+	pageId: option("--page-id", integer({ metavar: "ID" })),
+	type: option("--type", string({ metavar: "TYPE" })),
+	content: option("--content", string({ metavar: "JSON" })),
+	settings: optional(option("--settings", string({ metavar: "JSON" }))),
+	afterPosition: optional(option("--after-position", string({ metavar: "POS" }))),
+	project: projectFlag$2,
+	production: productionFlag$2,
+	json: jsonFlag$2
+})), command("edit", object({
+	command: constant("blocks.edit"),
+	id: option("--id", integer({ metavar: "ID" })),
+	content: optional(option("--content", string({ metavar: "JSON" }))),
+	settings: optional(option("--settings", string({ metavar: "JSON" }))),
+	project: projectFlag$2,
+	production: productionFlag$2,
+	json: jsonFlag$2
+})), command("move", object({
+	command: constant("blocks.move"),
+	id: option("--id", integer({ metavar: "ID" })),
+	afterPosition: optional(option("--after-position", string({ metavar: "POS" }))),
+	project: projectFlag$2,
+	production: productionFlag$2,
+	json: jsonFlag$2
+})), command("delete", object({
+	command: constant("blocks.delete"),
+	id: option("--id", integer({ metavar: "ID" })),
+	project: projectFlag$2,
+	production: productionFlag$2,
+	json: jsonFlag$2
+}))));
+async function handler$6(args) {
+	const outputMode = args.json ? "json" : "auto";
+	const projectFlag = args.project;
+	const production = args.production;
+	try {
+		switch (args.command) {
+			case "blocks.types": return dispatch({
+				toolName: "listBlockTypes",
+				args: {},
+				projectFlag,
+				production,
+				outputMode
+			});
+			case "blocks.describe": return dispatch({
+				toolName: "describeBlockTypes",
+				args: { types: [...args.type] },
+				projectFlag,
+				production,
+				outputMode
+			});
+			case "blocks.create": {
+				const content = parseJsonFlag("--content", args.content);
+				const settings = args.settings !== void 0 ? parseJsonFlag("--settings", args.settings) : void 0;
+				return dispatch({
+					toolName: "createBlock",
+					args: {
+						pageId: args.pageId,
+						type: args.type,
+						content,
+						settings,
+						afterPosition: args.afterPosition
+					},
+					projectFlag,
+					production,
+					outputMode
+				});
+			}
+			case "blocks.edit": {
+				const content = args.content !== void 0 ? parseJsonFlag("--content", args.content) : void 0;
+				const settings = args.settings !== void 0 ? parseJsonFlag("--settings", args.settings) : void 0;
+				return dispatch({
+					toolName: "editBlock",
+					args: {
+						id: args.id,
+						content,
+						settings
+					},
+					projectFlag,
+					production,
+					outputMode
+				});
+			}
+			case "blocks.move": return dispatch({
+				toolName: "moveBlock",
+				args: {
+					id: args.id,
+					afterPosition: args.afterPosition
+				},
+				projectFlag,
+				production,
+				outputMode
+			});
+			case "blocks.delete": return dispatch({
+				toolName: "deleteBlock",
+				args: { id: args.id },
+				projectFlag,
+				production,
+				outputMode
+			});
+		}
+	} catch (err) {
+		printError(asCliError(err));
+		process.exit(1);
+	}
+}
+//#endregion
 //#region src/lib/utils.ts
 const pmCommands = {
 	pnpm: {
@@ -220,13 +519,8 @@ function copyDir(src, dest, replacements) {
 }
 //#endregion
 //#region src/commands/init.ts
-var init_exports = /* @__PURE__ */ __exportAll({
-	handler: () => handler$2,
-	init: () => init,
-	parser: () => parser$2
-});
-const parser$2 = command("init", object({ command: constant("init") }));
-const handler$2 = init;
+const parser$5 = command("init", object({ command: constant("init") }));
+const handler$5 = init;
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const ownPkg = JSON.parse(fs.readFileSync(path.resolve(__dirname, "..", "package.json"), "utf-8"));
 function onCancel() {
@@ -434,14 +728,34 @@ src/routeTree.gen.ts
 	});
 }
 //#endregion
+//#region src/commands/layouts.ts
+const projectFlag$1 = optional(option("--project", string({ metavar: "SLUG" })));
+const jsonFlag$1 = option("--json");
+const productionFlag$1 = option("--production");
+const parser$4 = command("layouts", or(command("list", object({
+	command: constant("layouts.list"),
+	project: projectFlag$1,
+	production: productionFlag$1,
+	json: jsonFlag$1
+}))));
+async function handler$4(args) {
+	const outputMode = args.json ? "json" : "auto";
+	const projectFlag = args.project;
+	const production = args.production;
+	switch (args.command) {
+		case "layouts.list": return dispatch({
+			toolName: "listLayouts",
+			args: {},
+			projectFlag,
+			production,
+			outputMode
+		});
+	}
+}
+//#endregion
 //#region src/commands/login.ts
-var login_exports = /* @__PURE__ */ __exportAll({
-	handler: () => handler$1,
-	login: () => login,
-	parser: () => parser$1
-});
-const parser$1 = command("login", object({ command: constant("login") }));
-const handler$1 = login;
+const parser$3 = command("login", object({ command: constant("login") }));
+const handler$3 = login;
 async function login() {
 	p.intro("camox login");
 	try {
@@ -455,13 +769,8 @@ async function login() {
 }
 //#endregion
 //#region src/commands/logout.ts
-var logout_exports = /* @__PURE__ */ __exportAll({
-	handler: () => handler,
-	logout: () => logout,
-	parser: () => parser
-});
-const parser = command("logout", object({ command: constant("logout") }));
-const handler = logout;
+const parser$2 = command("logout", object({ command: constant("logout") }));
+const handler$2 = logout;
 function logout() {
 	p.intro("camox logout");
 	const token = readAuthToken();
@@ -473,17 +782,211 @@ function logout() {
 	p.log.success(`Logged out from ${token.name}.`);
 }
 //#endregion
+//#region src/commands/pages.ts
+const projectFlag = optional(option("--project", string({ metavar: "SLUG" })));
+const jsonFlag = option("--json");
+const productionFlag = option("--production");
+const parser$1 = command("pages", or(command("list", object({
+	command: constant("pages.list"),
+	project: projectFlag,
+	production: productionFlag,
+	json: jsonFlag
+})), command("get", object({
+	command: constant("pages.get"),
+	id: optional(option("--id", integer({ metavar: "ID" }))),
+	path: optional(option("--path", string({ metavar: "PATH" }))),
+	project: projectFlag,
+	production: productionFlag,
+	json: jsonFlag
+})), command("create", object({
+	command: constant("pages.create"),
+	pathSegment: option("--path-segment", string({ metavar: "SEGMENT" })),
+	layoutId: option("--layout-id", integer({ metavar: "ID" })),
+	parentPageId: optional(option("--parent-page-id", integer({ metavar: "ID" }))),
+	contentDescription: optional(option("--content-description", string({ metavar: "TEXT" }))),
+	project: projectFlag,
+	production: productionFlag,
+	json: jsonFlag
+})), command("update", object({
+	command: constant("pages.update"),
+	id: option("--id", integer({ metavar: "ID" })),
+	pathSegment: optional(option("--path-segment", string({ metavar: "SEGMENT" }))),
+	parentPageId: optional(option("--parent-page-id", integer({ metavar: "ID" }))),
+	project: projectFlag,
+	production: productionFlag,
+	json: jsonFlag
+})), command("set-layout", object({
+	command: constant("pages.set-layout"),
+	id: option("--id", integer({ metavar: "ID" })),
+	layoutId: option("--layout-id", integer({ metavar: "ID" })),
+	project: projectFlag,
+	production: productionFlag,
+	json: jsonFlag
+})), command("delete", object({
+	command: constant("pages.delete"),
+	id: option("--id", integer({ metavar: "ID" })),
+	project: projectFlag,
+	production: productionFlag,
+	json: jsonFlag
+}))));
+async function handler$1(args) {
+	const outputMode = args.json ? "json" : "auto";
+	const projectFlag = args.project;
+	const production = args.production;
+	switch (args.command) {
+		case "pages.list": return dispatch({
+			toolName: "listPages",
+			args: {},
+			projectFlag,
+			production,
+			outputMode
+		});
+		case "pages.get":
+			if (args.id == null === (args.path == null)) {
+				printError({
+					code: "INVALID_ARGS",
+					message: "Pass exactly one of --id or --path."
+				});
+				process.exit(2);
+			}
+			return dispatch({
+				toolName: "getPage",
+				args: args.id != null ? { id: args.id } : { path: args.path },
+				projectFlag,
+				production,
+				outputMode
+			});
+		case "pages.create": return dispatch({
+			toolName: "createPage",
+			args: {
+				pathSegment: args.pathSegment,
+				layoutId: args.layoutId,
+				parentPageId: args.parentPageId,
+				contentDescription: args.contentDescription
+			},
+			projectFlag,
+			production,
+			outputMode
+		});
+		case "pages.update": return dispatch({
+			toolName: "updatePage",
+			args: {
+				id: args.id,
+				pathSegment: args.pathSegment,
+				parentPageId: args.parentPageId
+			},
+			projectFlag,
+			production,
+			outputMode
+		});
+		case "pages.set-layout": return dispatch({
+			toolName: "setPageLayout",
+			args: {
+				id: args.id,
+				layoutId: args.layoutId
+			},
+			projectFlag,
+			production,
+			outputMode
+		});
+		case "pages.delete": return dispatch({
+			toolName: "deletePage",
+			args: { id: args.id },
+			projectFlag,
+			production,
+			outputMode
+		});
+	}
+}
+//#endregion
+//#region src/commands/status.ts
+const parser = command("status", object({
+	command: constant("status"),
+	production: option("--production"),
+	json: option("--json")
+}));
+async function handler(args) {
+	let runtime;
+	try {
+		runtime = loadRuntime();
+	} catch (err) {
+		if (err instanceof RuntimeNotFoundError || err instanceof RuntimeMalformedError) {
+			printError({
+				code: "RUNTIME_NOT_FOUND",
+				message: err.message
+			});
+			process.exit(2);
+		}
+		throw err;
+	}
+	const environmentName = args.production ? "production" : runtime.environmentName;
+	const token = readAuthTokenForUrl(runtime.authenticationUrl);
+	const status = {
+		projectSlug: runtime.projectSlug,
+		environmentName,
+		apiUrl: runtime.apiUrl,
+		authenticationUrl: runtime.authenticationUrl,
+		authenticated: token !== null,
+		user: token ? {
+			name: token.name,
+			email: token.email
+		} : null
+	};
+	if (args.json || !process.stdout.isTTY) {
+		process.stdout.write(`${JSON.stringify(status, null, process.stdout.isTTY ? 2 : 0)}\n`);
+		process.exit(0);
+	}
+	const lines = [
+		`project:     ${status.projectSlug}`,
+		`environment: ${status.environmentName}`,
+		`api:         ${status.apiUrl}`,
+		`auth:        ${status.authenticationUrl}`,
+		status.user ? `signed in:   ${status.user.name} <${status.user.email}>` : `signed in:   (no token for ${status.authenticationUrl} — run \`camox login\`)`
+	];
+	process.stdout.write(`${lines.join("\n")}\n`);
+	process.exit(0);
+}
+//#endregion
 //#region src/index.ts
-await {
-	init: init_exports,
-	login: login_exports,
-	logout: logout_exports
-}[run(defineProgram({
-	parser: or(parser$2, parser$1, parser),
+const result = runSync(defineProgram({
+	parser: or(parser$5, parser$3, parser$2, parser, parser$1, parser$6, parser$4),
 	metadata: {
 		name: "camox",
 		brief: message`Camox CLI`
 	}
-}), { help: "both" }).command].handler();
+}), { help: "both" });
+switch (result.command) {
+	case "init":
+		await handler$5();
+		break;
+	case "login":
+		await handler$3();
+		break;
+	case "logout":
+		await handler$2();
+		break;
+	case "status":
+		await handler(result);
+		break;
+	case "pages.list":
+	case "pages.get":
+	case "pages.create":
+	case "pages.update":
+	case "pages.set-layout":
+	case "pages.delete":
+		await handler$1(result);
+		break;
+	case "blocks.types":
+	case "blocks.describe":
+	case "blocks.create":
+	case "blocks.edit":
+	case "blocks.move":
+	case "blocks.delete":
+		await handler$6(result);
+		break;
+	case "layouts.list":
+		await handler$4(result);
+		break;
+}
 //#endregion
 export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@camox/cli",
-  "version": "0.14.2",
+  "version": "0.15.1",
   "bin": {
     "camox": "./dist/index.mjs"
   },
@@ -19,14 +19,15 @@
     "@optique/run": "*",
     "@orpc/client": "^1.13.14",
     "@orpc/server": "^1.13.14",
-    "slugify": "^1.6.9"
+    "slugify": "^1.6.9",
+    "zod": "^4.3.6"
   },
   "devDependencies": {
     "@types/node": "^24.12.2",
     "@typescript/native-preview": "7.0.0-dev.20260412.1",
     "oxlint": "^0.15.0",
     "tsdown": "^0.21.8",
-    "@camox/api-contract": "0.14.2"
+    "@camox/api-contract": "0.15.1"
   },
   "nx": {
     "tags": [

package/template/package.json

@@ -9,8 +9,7 @@
     "build": "vp build",
     "serve": "vp preview",
     "lint": "vp lint",
-    "check": "vp check",
-    "prepare": "vp config"
+    "check": "vp check"
   },
   "dependencies": {
     "@base-ui/react": "^1.4.0",

package/template/vite.config.ts

@@ -9,9 +9,6 @@ import { defineConfig, loadEnv } from "vite-plus";
 const env = loadEnv(process.env.NODE_ENV!, process.cwd(), "CAMOX_");
 
 export default defineConfig({
-  staged: {
-    "*": "vp check --fix"
-  },
   resolve: { tsconfigPaths: true },
   plugins: [
     tailwindcss(),

package/dist/api-CB7vjDU7.mjs

@@ -1,3 +0,0 @@
-#!/usr/bin/env node
-import { o as verifySession } from "./api-QINint5w.mjs";
-export { verifySession };

package/template/.vite-hooks/pre-commit

@@ -1 +0,0 @@
-vp staged