vite-plugin-windmill 1.687.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Jerry
+
+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,164 @@
+# vite-plugin-windmill
+
+Vite plugin and deploy tooling for Windmill raw apps.
+
+## Features
+
+- infers a Windmill raw-app path and `base` from a `.raw_app` or `__raw_app` directory
+- injects a virtual `wmill` runtime for local dev and production builds
+- configures authenticated `/api` proxying for Vite dev and preview when a Windmill URL and token are available
+- assembles raw-app payloads from `raw_app.yaml`, `backend/`, and tracked app files
+- honors repo `wmill.yaml` exclude globs when collecting app files for deploy
+- optionally deploys the built raw app after `vite build`
+
+## Versioning
+
+This package version tracks Windmill minor releases. New package versions are published for new Windmill minor lines; patch releases within a line are absorbed by the `windmill-client` range and the pinned generated runtime source.
+
+<!-- windmill-release:compat-start -->
+
+Current release line: `1.687.x`
+
+It currently depends on `windmill-client@^1.687.0` and bundles `rawAppWmillTs.ts` generated from `windmill-labs/windmill@v1.687.0`.
+
+<!-- windmill-release:compat-end -->
+
+## Install
+
+```bash
+pnpm add -D vite vite-plugin-windmill
+```
+
+`vite` is a peer dependency. `windmill-client` and `yaml` are bundled runtime dependencies. The package currently targets Node.js 22+.
+
+## Usage
+
+```ts
+import { defineConfig } from "vite";
+import windmill from "vite-plugin-windmill";
+
+export default defineConfig({
+  plugins: [windmill({ entry: "src/main.tsx" })],
+});
+```
+
+Expected project shape:
+
+```text
+f/example/app.raw_app/
+  raw_app.yaml
+  index.tsx
+  backend/
+    hello.py
+    hello.yaml
+```
+
+The plugin resolves the raw-app directory from `dir` or by searching upward for `raw_app.yaml`. It infers the Windmill app path from the raw-app folder name, so `f/example/app.raw_app` becomes `f/example/app`.
+
+## Options
+
+`windmill(options)` accepts:
+
+- `dir`: raw-app directory. Defaults to the nearest ancestor containing `raw_app.yaml`.
+- `entry`: entry file relative to `dir`. Defaults to `index.ts` or `index.tsx`.
+- `path`: override the inferred Windmill app path.
+- `base`: override the inferred raw-app base URL.
+- `root`: workspace root used for path inference and `wmill.yaml` discovery.
+- `workspace`: Windmill workspace override.
+- `token`: Windmill API token override.
+- `url`: Windmill base URL override.
+- `proxy`: `false` to disable proxying, or an object with `context`, `target`, `token`, and any Vite proxy options.
+- `deploy`: `true`, `false`, or `{ dry?: boolean; message?: string }`.
+- `nonDotted`: override `wmill.yaml` `nonDottedPaths`.
+- `ts`: default TypeScript runnable language override.
+
+Connection resolution order:
+
+- `workspace`: plugin option `workspace`, then `WM_WORKSPACE`
+- `token`: plugin option `token`, then `WM_TOKEN`
+- `url`: plugin option `url`, then `BASE_INTERNAL_URL`, then `BASE_URL`
+
+By default, the plugin adds a shared `/api` proxy for both `vite dev` and `vite preview` when it can resolve a Windmill URL and token from plugin options or from `BASE_INTERNAL_URL` or `BASE_URL` plus `WM_TOKEN`.
+
+Use `proxy: false` to disable it, or pass overrides such as `proxy: { context: '/wm-api', target: 'https://windmill.internal', token: process.env.WM_TOKEN }`.
+
+## Deploy After Build
+
+The plugin can deploy the built raw-app bundle after `vite build`.
+
+```ts
+windmill({
+  deploy: true,
+  entry: "src/main.tsx",
+});
+```
+
+`deploy` also accepts an options object:
+
+```ts
+windmill({
+  deploy: {
+    dry: true,
+    message: "preview release",
+  },
+});
+```
+
+Behavior:
+
+- `deploy: true`: deploy after build
+- `deploy: { dry: true }`: validate the local deploy payload without contacting or mutating Windmill
+- `deploy: { message: '...' }`: override the deployment message sent to Windmill
+- explicit `deploy` config wins over `WM_DEPLOY`
+
+If you prefer environment-driven deploys, leave `deploy` unset and use `WM_DEPLOY`:
+
+```bash
+WM_DEPLOY=true vite build
+WM_DEPLOY=dry vite build
+```
+
+Accepted `WM_DEPLOY` values:
+
+- truthy: `true`, `1`, `yes`, `on`, empty string
+- falsy: `false`, `0`, `no`, `off`
+- dry-run: `dry`, `check`
+
+## Deploy CLI
+
+The package also exposes a deploy CLI:
+
+```bash
+vite-plugin-windmill --dir ./f/example/app.raw_app --dry
+```
+
+Use `vite-plugin-windmill --help` for all flags.
+
+## Programmatic Deploy
+
+You can also deploy outside the Vite plugin lifecycle:
+
+```ts
+import { deploy } from "vite-plugin-windmill";
+
+await deploy({
+  dir: "./f/example/app.raw_app",
+  dry: true,
+  workspace: process.env.WM_WORKSPACE,
+  token: process.env.WM_TOKEN,
+  url: process.env.BASE_URL,
+});
+```
+
+`deploy()` resolves the same raw-app metadata as the plugin and accepts optional `bundles`, `js`, and `css` overrides when you want to supply build artifacts explicitly.
+
+## Example Scripts
+
+```json
+{
+  "scripts": {
+    "bundle": "vite build",
+    "deploy": "WM_DEPLOY=\"${WM_DEPLOY:-true}\" vite build"
+  }
+}
+```

package/bin/vite-plugin-windmill

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+
+import '../dist/cli.mjs'

package/dist/cli.d.mts

@@ -0,0 +1,4 @@
+//#region src/cli.d.ts
+declare const main: () => Promise<void>;
+//#endregion
+export { main };

package/dist/cli.mjs

@@ -0,0 +1,475 @@
+#!/usr/bin/env node
+import { parseArgs } from "node:util";
+import { access, readFile, readdir } from "node:fs/promises";
+import path from "node:path";
+import { ApiError, AppService, setClient } from "windmill-client";
+import { createHash } from "node:crypto";
+import { parse } from "yaml";
+//#region src/project.ts
+const RAW_APP_FOLDER_SUFFIXES = [".raw_app", "__raw_app"];
+const RAW_APP_FILE_NAME = "raw_app.yaml";
+const WMILL_CONFIG_FILE_NAME = "wmill.yaml";
+const DEPLOY_IGNORED_FILE_NAMES = new Set([
+	"AGENTS.md",
+	"DATATABLES.md",
+	"package-lock.json",
+	"raw_app.yaml",
+	"wmill.d.ts"
+]);
+const DEPLOY_IGNORED_DIRECTORIES = new Set([
+	".claude",
+	"backend",
+	"dist",
+	"node_modules",
+	"sql_to_apply"
+]);
+const LANGUAGE_BY_EXTENSION = {
+	"bq.sql": "bigquery",
+	"bun.ts": "bun",
+	cs: "csharp",
+	"deno.ts": "deno",
+	"duckdb.sql": "duckdb",
+	"frontend.js": "frontend",
+	go: "go",
+	gql: "graphql",
+	java: "java",
+	"ms.sql": "mssql",
+	"my.sql": "mysql",
+	"native.ts": "nativets",
+	nu: "nu",
+	"odb.sql": "oracledb",
+	"pg.sql": "postgresql",
+	php: "php",
+	"playbook.yml": "ansible",
+	ps1: "powershell",
+	py: "python3",
+	rb: "ruby",
+	rs: "rust",
+	"sf.sql": "snowflake",
+	sh: "bash",
+	ts: "bun"
+};
+const isNodeError = (value) => value instanceof Error && "code" in value;
+const pathExists = async (filePath) => {
+	try {
+		await access(filePath);
+		return true;
+	} catch {
+		return false;
+	}
+};
+const normalizeToPosix = (value) => value.split(path.sep).join("/");
+const dirnameIfPossible = (value) => {
+	const parent = path.dirname(value);
+	return parent === value ? void 0 : parent;
+};
+const findUp = async (startDir, fileName) => {
+	let currentDir = path.resolve(startDir);
+	while (true) {
+		const candidate = path.join(currentDir, fileName);
+		if (await pathExists(candidate)) return candidate;
+		const parentDir = dirnameIfPossible(currentDir);
+		if (!parentDir) return void 0;
+		currentDir = parentDir;
+	}
+};
+const parseYamlFile = async (filePath) => {
+	return parse(await readFile(filePath, "utf8"));
+};
+const resolveRoot = async (explicitRoot, dir) => {
+	if (explicitRoot) {
+		const root = path.resolve(explicitRoot);
+		return {
+			path: await pathExists(path.join(root, WMILL_CONFIG_FILE_NAME)) ? path.join(root, WMILL_CONFIG_FILE_NAME) : void 0,
+			root
+		};
+	}
+	const configPath = await findUp(dir, WMILL_CONFIG_FILE_NAME);
+	return {
+		path: configPath,
+		root: configPath ? path.dirname(configPath) : dir
+	};
+};
+const resolveDir = async (explicitDir) => {
+	const candidate = path.resolve(explicitDir ?? process.cwd());
+	const rawAppPath = await findUp(candidate, RAW_APP_FILE_NAME);
+	if (!rawAppPath) throw new Error(`Could not find ${RAW_APP_FILE_NAME} from ${candidate}`);
+	return path.dirname(rawAppPath);
+};
+const stripRawAppSuffix = (folderName) => {
+	for (const suffix of RAW_APP_FOLDER_SUFFIXES) if (folderName.endsWith(suffix)) return folderName.slice(0, -suffix.length);
+};
+const inferPath = (dir, root) => {
+	const segments = normalizeToPosix(path.relative(root, dir)).split("/").filter(Boolean);
+	if (segments.length === 0) throw new Error(`Could not infer a Windmill app path from ${dir}`);
+	const lastSegment = segments.at(-1);
+	if (!lastSegment) throw new Error(`Could not infer a Windmill app path from ${dir}`);
+	const strippedSegment = stripRawAppSuffix(lastSegment);
+	if (!strippedSegment) throw new Error(`Expected ${dir} to end in .raw_app or __raw_app so the app path can be inferred`);
+	return [...segments.slice(0, -1), strippedSegment].join("/");
+};
+const inferBase = (pathValue) => `/apps_raw/get/${pathValue}/`;
+const resolveEntry = async (dir, value) => {
+	if (value) {
+		const entry = path.resolve(dir, value);
+		if (!await pathExists(entry)) throw new Error(`Entry file does not exist: ${entry}`);
+		return entry;
+	}
+	const tsEntry = path.join(dir, "index.ts");
+	if (await pathExists(tsEntry)) return tsEntry;
+	const tsxEntry = path.join(dir, "index.tsx");
+	if (await pathExists(tsxEntry)) return tsxEntry;
+	throw new Error(`Could not find index.ts or index.tsx inside ${dir}`);
+};
+const resolveEnv = (options) => ({
+	url: options.url ?? process.env.BASE_INTERNAL_URL ?? process.env.BASE_URL,
+	token: options.token ?? process.env.WM_TOKEN,
+	workspace: options.workspace ?? process.env.WM_WORKSPACE
+});
+const resolveProject = async (options = {}) => {
+	const dir = await resolveDir(options.dir);
+	const { path: config, root } = await resolveRoot(options.root, dir);
+	const wmillConfig = config ? await parseYamlFile(config) : {};
+	const pathValue = options.path ?? inferPath(dir, root);
+	const entry = await resolveEntry(dir, options.entry);
+	const { url, token, workspace } = resolveEnv(options);
+	return {
+		base: options.base ?? inferBase(pathValue),
+		config,
+		dir,
+		entry,
+		nonDotted: options.nonDotted ?? wmillConfig.nonDottedPaths ?? false,
+		path: pathValue,
+		root,
+		syncExcludes: wmillConfig.excludes ?? [],
+		ts: options.ts ?? wmillConfig.defaultTs ?? "bun",
+		workspace,
+		token,
+		url,
+		yaml: path.join(dir, RAW_APP_FILE_NAME)
+	};
+};
+const collectStaticFields = (fields) => Object.fromEntries(Object.entries(fields ?? {}).filter(([, field]) => field.type === "static").map(([name, field]) => [name, field.value]));
+const createRawscriptHash = (content) => createHash("sha256").update(content ?? "").digest("hex");
+const resolveTriggerableEntry = async (runnableId, runnable) => {
+	const staticInputs = collectStaticFields(runnable.fields);
+	const allowUserResources = Object.entries(runnable.fields ?? {}).filter(([, field]) => field.allowUserResources).map(([name]) => name);
+	if (runnable.inlineScript) return [`${runnableId}:rawscript/${createRawscriptHash(runnable.inlineScript.content)}`, {
+		allow_user_resources: allowUserResources,
+		one_of_inputs: {},
+		static_inputs: staticInputs
+	}];
+	if (runnable.path && runnable.runType) return [`${runnableId}:${runnable.runType === "hubscript" ? "script" : runnable.runType}/${runnable.path}`, {
+		allow_user_resources: allowUserResources,
+		one_of_inputs: {},
+		static_inputs: staticInputs
+	}];
+};
+const generateRawAppPolicy = async (runnables, policy, isPublic) => {
+	const resolvedTriggerableEntries = (await Promise.all(Object.entries(runnables).map(async ([runnableId, runnable]) => resolveTriggerableEntry(runnableId, runnable)))).filter((entry) => entry !== void 0);
+	return {
+		...policy,
+		execution_mode: isPublic ? "anonymous" : "publisher",
+		triggerables_v2: Object.fromEntries(resolvedTriggerableEntries)
+	};
+};
+const resolveRunnableLanguage = (extension, ts) => {
+	const language = LANGUAGE_BY_EXTENSION[extension];
+	if (!language) return void 0;
+	return extension === "ts" ? ts : language;
+};
+const findRunnableContentFile = async (backendDir, runnableId, allFileNames) => {
+	for (const fileName of allFileNames) {
+		if (fileName.endsWith(".yaml") || fileName.endsWith(".lock")) continue;
+		if (!fileName.startsWith(`${runnableId}.`)) continue;
+		const extension = fileName.slice(runnableId.length + 1);
+		if (!resolveRunnableLanguage(extension, "bun")) continue;
+		return {
+			content: await readFile(path.join(backendDir, fileName), "utf8"),
+			extension
+		};
+	}
+};
+const getRunnableIdFromCodeFile = (fileName) => {
+	if (fileName.endsWith(".yaml") || fileName.endsWith(".lock")) return void 0;
+	for (const extension of Object.keys(LANGUAGE_BY_EXTENSION)) if (fileName.endsWith(`.${extension}`)) return fileName.slice(0, -(extension.length + 1));
+};
+const inlinePathPrefix = "!inline ";
+const dereferenceInlineValue = async (value, localPath) => {
+	if (typeof value !== "string" || !value.startsWith(inlinePathPrefix)) return value;
+	const relativePath = value.slice(8);
+	return readFile(path.join(localPath, relativePath), "utf8");
+};
+const cloneRunnable = async (value, localPath) => {
+	if (Array.isArray(value)) return Promise.all(value.map(async (item) => cloneRunnable(item, localPath)));
+	if (typeof value !== "object" || value === null) return dereferenceInlineValue(value, localPath);
+	const entries = await Promise.all(Object.entries(value).map(async ([key, entryValue]) => [key, await cloneRunnable(entryValue, localPath)]));
+	return Object.fromEntries(entries);
+};
+const loadRunnablesFromBackend = async (backendDir, ts = "bun") => {
+	const runnables = {};
+	try {
+		const allFileNames = (await readdir(backendDir, { withFileTypes: true })).filter((entry) => entry.isFile()).map((entry) => entry.name);
+		const processedIds = /* @__PURE__ */ new Set();
+		for (const fileName of allFileNames) {
+			if (!fileName.endsWith(".yaml")) continue;
+			const runnableId = fileName.slice(0, -5);
+			processedIds.add(runnableId);
+			const runnable = await parseYamlFile(path.join(backendDir, fileName));
+			if (runnable.type === "inline") {
+				const contentFile = await findRunnableContentFile(backendDir, runnableId, allFileNames);
+				if (contentFile) {
+					const lockPath = path.join(backendDir, `${runnableId}.lock`);
+					let lock;
+					try {
+						lock = await readFile(lockPath, "utf8");
+					} catch (error) {
+						if (!isNodeError(error) || error.code !== "ENOENT") throw error;
+					}
+					runnable.inlineScript = {
+						...runnable.inlineScript,
+						content: contentFile.content,
+						language: resolveRunnableLanguage(contentFile.extension, ts),
+						...lock ? { lock } : {}
+					};
+				}
+			} else if (runnable.type === "flow" || runnable.type === "hubscript" || runnable.type === "script") {
+				const { type, schema: _schema, ...rest } = runnable;
+				runnables[runnableId] = {
+					...rest,
+					runType: type,
+					type: "path"
+				};
+				continue;
+			}
+			runnables[runnableId] = runnable;
+		}
+		for (const fileName of allFileNames) {
+			const runnableId = getRunnableIdFromCodeFile(fileName);
+			if (!runnableId || processedIds.has(runnableId)) continue;
+			processedIds.add(runnableId);
+			const contentFile = await findRunnableContentFile(backendDir, runnableId, allFileNames);
+			if (!contentFile) continue;
+			const lockPath = path.join(backendDir, `${runnableId}.lock`);
+			let lock;
+			try {
+				lock = await readFile(lockPath, "utf8");
+			} catch (error) {
+				if (!isNodeError(error) || error.code !== "ENOENT") throw error;
+			}
+			runnables[runnableId] = {
+				inlineScript: {
+					content: contentFile.content,
+					language: resolveRunnableLanguage(contentFile.extension, ts),
+					...lock ? { lock } : {}
+				},
+				type: "inline"
+			};
+		}
+	} catch (error) {
+		if (!isNodeError(error) || error.code !== "ENOENT") throw error;
+	}
+	return runnables;
+};
+const matchesSyncExclude = (relativePath, excludes) => excludes.some((pattern) => path.posix.matchesGlob(relativePath, pattern));
+const collectAppFiles = async (dir, options = {}) => {
+	const files = {};
+	const root = options.root ? path.resolve(options.root) : dir;
+	const excludes = options.excludes ?? [];
+	const walk = async (currentDir, relativeDir = "/") => {
+		const entries = await readdir(currentDir, { withFileTypes: true });
+		for (const entry of entries) {
+			const fullPath = path.join(currentDir, entry.name);
+			const relativePath = `${relativeDir}${entry.name}`;
+			const relativeToRoot = normalizeToPosix(path.relative(root, fullPath));
+			if (entry.isDirectory()) {
+				if (DEPLOY_IGNORED_DIRECTORIES.has(entry.name)) continue;
+				await walk(fullPath, `${relativePath}/`);
+				continue;
+			}
+			if (DEPLOY_IGNORED_FILE_NAMES.has(entry.name)) continue;
+			if (matchesSyncExclude(relativeToRoot, excludes)) continue;
+			files[relativePath] = await readFile(fullPath, "utf8");
+		}
+	};
+	await walk(dir);
+	return files;
+};
+const loadRawAppProject = async (project) => {
+	const config = await parseYamlFile(project.yaml);
+	const backendDir = path.join(project.dir, "backend");
+	const backendRunnables = await loadRunnablesFromBackend(backendDir, project.ts);
+	const runnables = await cloneRunnable(Object.keys(backendRunnables).length > 0 ? backendRunnables : config.runnables ?? {}, backendDir);
+	const files = await collectAppFiles(project.dir, {
+		excludes: project.syncExcludes,
+		root: project.root
+	});
+	return {
+		config,
+		files,
+		policy: await generateRawAppPolicy(runnables, config.policy, Boolean(config.public)),
+		runnables,
+		value: {
+			...config.data !== void 0 ? { data: config.data } : {},
+			files,
+			runnables
+		}
+	};
+};
+//#endregion
+//#region src/deploy.ts
+const defaultDeploymentMessage = () => {
+	const sha = process.env.GITHUB_SHA;
+	return sha ? `vite-plugin-windmill deploy ${sha}` : "vite-plugin-windmill deploy";
+};
+const requireProjectConnection = (project) => {
+	if (!project.workspace) throw new Error("Missing Windmill workspace. Set `workspace` or `WM_WORKSPACE`.");
+	if (!project.token) throw new Error("Missing Windmill token. Set `token` or `WM_TOKEN`.");
+	if (!project.url) throw new Error("Missing Windmill URL. Set `url`, `BASE_INTERNAL_URL`, or `BASE_URL`.");
+	return {
+		url: project.url,
+		token: project.token,
+		workspace: project.workspace
+	};
+};
+const readBundleFile = async (filePath, fallback = "") => {
+	try {
+		return await readFile(filePath, "utf8");
+	} catch (error) {
+		if (error instanceof Error && "code" in error && error.code === "ENOENT") return fallback;
+		throw error;
+	}
+};
+const readBundleContents = async (dir, js = path.join(dir, "dist/windmill/bundle.js"), css = path.join(dir, "dist/windmill/bundle.css")) => ({
+	css: await readBundleFile(css, ""),
+	js: await readBundleFile(js)
+});
+const findExistingRawApp = async (workspace, pathValue) => {
+	try {
+		return await AppService.getAppByPath({
+			workspace,
+			path: pathValue
+		});
+	} catch (error) {
+		if (error instanceof ApiError && error.status === 404) return void 0;
+		throw error;
+	}
+};
+/**
+* Deploys a raw app to Windmill using `windmill-client` instead of shelling out to the CLI.
+*/
+const deploy = async (options) => {
+	const dir = options.dir ?? process.cwd();
+	const project = await resolveProject({
+		...options,
+		dir
+	});
+	const rawAppProject = await loadRawAppProject(project);
+	const connection = requireProjectConnection(project);
+	const bundles = options.bundles ?? await readBundleContents(dir, options.js, options.css);
+	if (!bundles.js) throw new Error("Cannot deploy a Windmill raw app without a JavaScript bundle");
+	if (options.dry) return {
+		action: "dry-run",
+		base: project.base,
+		path: project.path,
+		workspace: connection.workspace
+	};
+	setClient(connection.token, connection.url);
+	const existingApp = await findExistingRawApp(connection.workspace, project.path);
+	if (existingApp && !existingApp.raw_app) throw new Error(`${project.path} exists remotely but is not a raw app`);
+	const message = options.message ?? defaultDeploymentMessage();
+	const appPayload = {
+		...rawAppProject.config.custom_path ? { custom_path: rawAppProject.config.custom_path } : {},
+		deployment_message: message,
+		path: project.path,
+		policy: rawAppProject.policy,
+		summary: rawAppProject.config.summary,
+		value: rawAppProject.value
+	};
+	if (existingApp) {
+		await AppService.updateAppRaw({
+			workspace: connection.workspace,
+			path: project.path,
+			formData: {
+				app: appPayload,
+				css: bundles.css,
+				js: bundles.js
+			}
+		});
+		return {
+			action: "update",
+			base: project.base,
+			path: project.path,
+			workspace: connection.workspace
+		};
+	}
+	await AppService.createAppRaw({
+		workspace: connection.workspace,
+		formData: {
+			app: appPayload,
+			css: bundles.css,
+			js: bundles.js
+		}
+	});
+	return {
+		action: "create",
+		base: project.base,
+		path: project.path,
+		workspace: connection.workspace
+	};
+};
+//#endregion
+//#region src/cli.ts
+const main = async () => {
+	const { values } = parseArgs({ options: {
+		base: { type: "string" },
+		css: { type: "string" },
+		dir: { type: "string" },
+		dry: { type: "boolean" },
+		entry: { type: "string" },
+		js: { type: "string" },
+		message: { type: "string" },
+		path: { type: "string" },
+		root: { type: "string" },
+		token: { type: "string" },
+		url: { type: "string" },
+		workspace: { type: "string" },
+		help: {
+			type: "boolean",
+			short: "h"
+		}
+	} });
+	if (values.help) return console.log(`
+Usage: vite-plugin-windmill [options]
+
+Deploy a built Windmill raw app bundle.
+
+Options:
+  -h, --help          Show this help message
+  --base <path>       Override the raw-app base path
+  --css <path>        Path to the CSS file to include in the deployment
+  --dir <path>        Raw-app directory to resolve and deploy from
+  --dry               Perform a dry run without making any changes
+  --entry <path>      Override the raw-app entry file
+  --js <path>         Path to the JavaScript file to include in the deployment
+  --message <text>    Deployment message or description
+  --path <path>       Override the inferred Windmill raw-app path
+  --root <path>       Override the workspace root used to infer the app path
+  --token <token>     Windmill API token for authentication
+  --url <url>         Windmill instance URL
+  --workspace <name>  Windmill workspace name
+
+Connection resolution order:
+  workspace: --workspace, WM_WORKSPACE
+  token:     --token, WM_TOKEN
+  url:       --url, BASE_INTERNAL_URL, BASE_URL
+     `.trim());
+	const result = await deploy(values);
+	console.log(JSON.stringify(result, null, 2));
+};
+main().catch((error) => {
+	console.error(error instanceof Error ? error.message : String(error));
+	process.exitCode = 1;
+});
+//#endregion
+export { main };