silgi 0.43.28 → 0.50.0

package/dist/cli/build/prepare.mjs

@@ -1,15 +0,0 @@
-import { createSilgiCLI } from "../core/silgi.mjs";
-import { build } from "./build.mjs";
-
-//#region src/cli/build/prepare.ts
-async function prepareBuild(config) {
-	const silgi = await createSilgiCLI({
-		commandType: config?.commandType || "prepare",
-		...config
-	});
-	await build(silgi);
-	return silgi;
-}
-
-//#endregion
-export { prepareBuild };

package/dist/cli/commands/commands.mjs

@@ -1,90 +0,0 @@
-import { silgiCLIIClose } from "../../core/silgiApp.mjs";
-import { prepareEnv } from "./env.mjs";
-import { loadOptions } from "../config/loader.mjs";
-import { cancelOnCancel } from "../utils/cancel.mjs";
-import { commonArgs } from "../utils/common.mjs";
-import prepare_default from "./prepare.mjs";
-import { consola as consola$1 } from "consola";
-import { useSilgiCLI } from "silgi";
-import * as p from "@clack/prompts";
-import { createJiti } from "dev-jiti";
-import { version } from "silgi/meta";
-import { defineCommand, runCommand } from "citty";
-import { execSync } from "node:child_process";
-
-//#region src/cli/commands/commands.ts
-const command = defineCommand({
-	meta: {
-		name: "run",
-		description: "Run a command from the CLI",
-		version
-	},
-	args: {
-		...commonArgs,
-		preset: {
-			type: "string",
-			description: "The build preset to use (you can also use `SILGI_PRESET` environment variable)."
-		},
-		tag: { type: "string" },
-		prepare: {
-			type: "boolean",
-			description: "Run in silgi development mode",
-			default: true
-		}
-	},
-	async run({ args }) {
-		if (args.prepare) await runCommand(prepare_default, { rawArgs: ["--commandType", "commands"] });
-		const silgi = useSilgiCLI();
-		if (!silgi) throw new Error("Silgi is not initialized");
-		const commands = silgi.options.commands;
-		const tags = args.tag?.split(",").map((t) => t.trim());
-		const silgiConfig = await loadOptions({});
-		await prepareEnv(silgiConfig);
-		let selectedCommands = [];
-		if (tags?.length) selectedCommands = commands.filter((cmd) => cmd.tags?.some((tag) => tags.includes(tag))).filter((cmd) => cmd.when !== false);
-		else selectedCommands = commands.filter((cmd) => cmd.when !== false);
-		if (!selectedCommands.length) return;
-		const multiSelect = await p.groupMultiselect({
-			message: "Select commands to run",
-			required: true,
-			options: { ...selectedCommands.sort((a, b) => (a.order || Infinity) - (b.order || Infinity)).reduce((acc, cmd) => {
-				const groupKey = cmd.group || "";
-				if (!acc[groupKey]) acc[groupKey] = [];
-				acc[groupKey].push({
-					label: cmd.name,
-					value: cmd,
-					hint: cmd.description
-				});
-				return acc;
-			}, {}) }
-		});
-		cancelOnCancel({ value: multiSelect });
-		selectedCommands = multiSelect;
-		const spinner = p.spinner({ indicator: "dots" });
-		for (const cmd of selectedCommands) {
-			const data = cmd.getContents({ app: silgi });
-			spinner.start(`[${cmd.group}] ${cmd.name}...`);
-			if (cmd.type === "command") execSync(data, { stdio: "inherit" });
-			if (cmd.type === "function") {
-				const jiti = createJiti(import.meta.url, { alias: silgiConfig.alias });
-				let cleanHandler = cmd.getContents({ app: silgi }).replace(/\n/g, "");
-				cleanHandler = `import { silgiCLICtx } from 'silgi' 
-        ${cleanHandler}
-`;
-				await jiti.evalModule(cleanHandler, {
-					filename: import.meta.url,
-					async: true,
-					conditions: silgiConfig.conditions,
-					forceTranspile: true
-				});
-			}
-			spinner.stop();
-			consola$1.success(`[${cmd.group}] ${cmd.name} done`);
-		}
-		await silgiCLIIClose();
-	}
-});
-var commands_default = command;
-
-//#endregion
-export { commands_default as default };

package/dist/cli/commands/env.mjs

@@ -1,53 +0,0 @@
-import { setupDotenv } from "../core/env.mjs";
-import * as p from "@clack/prompts";
-
-//#region src/cli/commands/env.ts
-let initialized = false;
-async function prepareEnv(silgiConfig) {
-	if (initialized) return;
-	initialized = true;
-	const customEnvironments = silgiConfig.environments;
-	const environment = silgiConfig.activeEnvironment ? silgiConfig.activeEnvironment : await p.select({
-		message: "Select an environment",
-		options: customEnvironments?.length > 0 ? customEnvironments.map((env) => ({
-			label: env.fileName,
-			value: env.fileName
-		})) : [
-			{
-				label: "Development (.env)",
-				value: ".env"
-			},
-			{
-				label: "Docker (.env.docker)",
-				value: "docker"
-			},
-			{
-				label: "Staging (.env.staging)",
-				value: "staging"
-			},
-			{
-				label: "Testing (.env.testing)",
-				value: "testing"
-			},
-			{
-				label: "Production (.env.prod)",
-				value: "prod"
-			}
-		]
-	});
-	const findEnv = customEnvironments?.find((env) => env.fileName === environment);
-	if (findEnv) await setupDotenv({
-		cwd: findEnv.cwd || silgiConfig.rootDir,
-		interpolate: findEnv.interpolate,
-		fileName: findEnv.fileName,
-		env: findEnv.env
-	});
-	else await setupDotenv({
-		cwd: silgiConfig.rootDir,
-		interpolate: true,
-		fileName: environment === ".env" ? ".env" : `.env.${environment}`
-	});
-}
-
-//#endregion
-export { prepareEnv };

package/dist/cli/commands/init.mjs

@@ -1,84 +0,0 @@
-import { cancelOnCancel } from "../utils/cancel.mjs";
-import prepare_default from "./prepare.mjs";
-import consola from "consola";
-import { dirname } from "pathe";
-import * as p from "@clack/prompts";
-import { writeFileSync } from "node:fs";
-import fsp from "node:fs/promises";
-import { defineCommand, runCommand } from "citty";
-
-//#region src/cli/commands/init.ts
-const command = defineCommand({
-	meta: {
-		name: "Silgi Init",
-		description: "Initialize silgi config",
-		version: "0.1.0"
-	},
-	args: {},
-	async run() {
-		p.intro("Initializing silgi config");
-		const framework = await p.select({
-			message: "Choose a framework",
-			options: [
-				{
-					label: "Nitro",
-					value: "nitro"
-				},
-				{
-					label: "Nuxt",
-					value: "nuxt"
-				},
-				{
-					label: "H3",
-					value: "h3"
-				},
-				{
-					label: "NPM Package",
-					value: "npm-package"
-				}
-			],
-			initialValue: "h3"
-		});
-		cancelOnCancel({ value: framework });
-		const context = [
-			`import { defineSilgiConfig } from 'silgi/config'`,
-			"",
-			"export default defineSilgiConfig({",
-			`  preset: '${framework}',`,
-			`  compatibilityDate: '${new Date().toISOString().split("T")[0]}',`,
-			"",
-			"})",
-			""
-		];
-		if (framework === "nitro" || framework === "nuxt") {
-			const plugin = [
-				`import { buildSilgi } from '../silgi/core'`,
-				"",
-				"export default defineNitroPlugin(async (nitro) => {",
-				"",
-				"  await buildSilgi({",
-				"    framework: {",
-				"      nitro,",
-				"    },",
-				"    options: {",
-				"      putStorage: useStorage(),",
-				"      runtimeConfig: useRuntimeConfig(),",
-				"    },",
-				"  })",
-				"})",
-				""
-			];
-			const file = "server/plugins/silgi.ts";
-			await fsp.mkdir(dirname(file), { recursive: true });
-			writeFileSync(file, plugin.join("\n"));
-			consola.success("Silgi plugin created, see server/plugins/silgi.ts");
-			runCommand(prepare_default, { rawArgs: ["--env", ".env"] });
-		}
-		writeFileSync("silgi.config.ts", context.join("\n"));
-		consola.success("Silgi config created, see silgi.config.ts");
-	}
-});
-var init_default = command;
-
-//#endregion
-export { init_default as default };

package/dist/cli/commands/install.mjs

@@ -1,52 +0,0 @@
-import { commonArgs } from "../utils/common.mjs";
-import prepare_default from "./prepare.mjs";
-import { installPackages } from "../core/installPackage.mjs";
-import { consola as consola$1 } from "consola";
-import { version } from "silgi/meta";
-import { defineCommand, runCommand } from "citty";
-import { execSync } from "node:child_process";
-
-//#region src/cli/commands/install.ts
-const command = defineCommand({
-	meta: {
-		name: "install",
-		description: "Install dependencies from the install.json file.",
-		version
-	},
-	args: {
-		...commonArgs,
-		preset: {
-			type: "string",
-			description: "The build preset to use (you can also use `SILGI_PRESET` environment variable)."
-		}
-	},
-	async run() {
-		await runCommand(prepare_default, { rawArgs: ["--commandType", "install"] }).catch(() => {});
-		const packages = await installPackages();
-		const commandArgs = process.argv.slice(process.argv.indexOf("install") + 1);
-		const extraArgs = commandArgs.length ? ` ${commandArgs.join(" ")}` : "";
-		if (Object.keys(packages).length === 0) {
-			consola$1.info("Empty command list, maybe forgot pnpm silgi prepare?");
-			return;
-		}
-		const cleanPackageName = (name, version$1) => {
-			const cleanVersion = version$1.replace(/^(>=|<=|>|<)/, "^");
-			return `${name}@${cleanVersion}`;
-		};
-		const deps = Object.entries(packages.dependencies || {}).map(([name, version$1]) => cleanPackageName(name, version$1)).join(" ");
-		const devDeps = Object.entries(packages.devDependencies || {}).map(([name, version$1]) => cleanPackageName(name, version$1)).join(" ");
-		if (deps) {
-			consola$1.info("Installing dependencies...");
-			execSync(`ni ${deps}${extraArgs}`, { stdio: "inherit" });
-		}
-		if (devDeps) {
-			consola$1.info("Installing dev dependencies...");
-			execSync(`ni ${devDeps}${extraArgs} -D`, { stdio: "inherit" });
-		}
-		consola$1.success("All dependencies installed successfully.");
-	}
-});
-var install_default = command;
-
-//#endregion
-export { install_default as default };

package/dist/cli/commands/prepare.mjs

@@ -1,65 +0,0 @@
-import { createSilgiCLI } from "../core/silgi.mjs";
-import { build } from "../build/build.mjs";
-import { commonArgs } from "../utils/common.mjs";
-import commands_default from "./commands.mjs";
-import { resolve } from "pathe";
-import { readPackageJSON } from "pkg-types";
-import { version } from "silgi/meta";
-import { defineCommand, runCommand } from "citty";
-
-//#region src/cli/commands/prepare.ts
-const command = defineCommand({
-	meta: {
-		name: "prepare",
-		description: "Generate types for the project",
-		version
-	},
-	args: {
-		...commonArgs,
-		preset: {
-			type: "string",
-			description: "The build preset to use (you can also use `SILGI_PRESET` environment variable)."
-		},
-		stub: {
-			type: "boolean",
-			description: "Run in silgi development mode"
-		},
-		dev: {
-			type: "boolean",
-			description: "Run in silgi development mode"
-		},
-		env: {
-			type: "string",
-			description: "The environment to use"
-		},
-		commandType: {
-			type: "string",
-			description: "The command type to run"
-		}
-	},
-	async run({ args }) {
-		const rootDir = resolve(args.dir || args._dir || ".");
-		const packageJson = await readPackageJSON(rootDir);
-		const packageName = packageJson.name || "";
-		const silgi = await createSilgiCLI({
-			rootDir,
-			dev: args.dev || args.stub,
-			stub: args.stub,
-			preset: args.preset,
-			commandType: args.commandType || "prepare",
-			activeEnvironment: args.env,
-			package: { name: packageName }
-		});
-		await build(silgi);
-		if (args.commandType !== "commands") await runCommand(commands_default, { rawArgs: [
-			"--tag",
-			"init",
-			"--prepare",
-			"false"
-		] });
-	}
-});
-var prepare_default = command;
-
-//#endregion
-export { prepare_default as default };

package/dist/cli/commands/reset.mjs

@@ -1,46 +0,0 @@
-import { loadOptions } from "../config/loader.mjs";
-import { commonArgs } from "../utils/common.mjs";
-import consola from "consola";
-import { join, resolve } from "pathe";
-import { version } from "silgi/meta";
-import fsp from "node:fs/promises";
-import { defineCommand } from "citty";
-
-//#region src/cli/commands/reset.ts
-const command = defineCommand({
-	meta: {
-		name: "prepare",
-		description: "Generate types for the project",
-		version
-	},
-	args: { ...commonArgs },
-	async run({ args }) {
-		const rootDir = resolve(args.dir || args._dir || ".");
-		const options = await loadOptions({ rootDir }, {});
-		const serverDir = options.silgi.serverDir;
-		const vfs = join(serverDir, "vfs");
-		const configs = join(serverDir, "configs.ts");
-		const core = join(serverDir, "core.ts");
-		const scan = join(serverDir, "scan.ts");
-		const meta = join(serverDir, "meta.ts");
-		const silgiDir = options.build.dir;
-		for (const file of [
-			vfs,
-			configs,
-			core,
-			scan,
-			silgiDir,
-			meta
-		]) try {
-			await fsp.rm(file, {
-				force: true,
-				recursive: true
-			});
-			consola.success(`Removed ${file.replace(rootDir, "")}`);
-		} catch {}
-	}
-});
-var reset_default = command;
-
-//#endregion
-export { reset_default as default };

package/dist/cli/commands/run.mjs

@@ -1,31 +0,0 @@
-import watch_default from "./watch.mjs";
-import consola from "consola";
-import { version } from "silgi/meta";
-import { runCommand } from "citty";
-
-//#region src/cli/commands/run.ts
-const command = {
-	meta: {
-		name: "run",
-		description: "Run a command with silgi watch (shortcut for \"silgi watch npm run <command>\")",
-		version
-	},
-	args: { command: {
-		type: "string",
-		description: "your application start command",
-		required: false
-	} },
-	async run({ args, rawArgs }) {
-		const command$1 = args.command || rawArgs[0];
-		if (command$1 && !command$1.includes(" ")) {
-			const fullCommand = `npm run ${command$1}`;
-			consola.info(`Running: ${fullCommand}`);
-			return runCommand(watch_default, { rawArgs: [fullCommand] });
-		}
-		return runCommand(watch_default, { rawArgs });
-	}
-};
-var run_default = command;
-
-//#endregion
-export { run_default as default };

package/dist/cli/commands/watch.mjs

@@ -1,153 +0,0 @@
-import { watchDev } from "../build/dev.mjs";
-import { commonArgs } from "../utils/common.mjs";
-import prepare_default from "./prepare.mjs";
-import { aggressiveCleanup, killPortProcesses, killProcessTree } from "../utils/processManager.mjs";
-import consola from "consola";
-import { version } from "silgi/meta";
-import { defineCommand, runCommand } from "citty";
-import { spawn } from "node:child_process";
-
-//#region src/cli/commands/watch.ts
-const runningProcesses = new Map();
-const openPorts = new Set();
-let watchHandle = null;
-let isShuttingDown = false;
-const isWindows = process.platform === "win32";
-function detectPort(data) {
-	const patterns = [
-		/localhost:(\d+)/i,
-		/127\.0\.0\.1:(\d+)/,
-		/0\.0\.0\.0:(\d+)/,
-		/\[::1\]:(\d+)/,
-		/Local:\s*http:\/\/[^:]+:(\d+)/i,
-		/➜\s+Local:\s+http:\/\/[^:]+:(\d+)/i
-	];
-	for (const pattern of patterns) {
-		const match = data.match(pattern);
-		if (match && match[1]) return Number.parseInt(match[1], 10);
-	}
-	return null;
-}
-async function shutdown() {
-	if (isShuttingDown) return;
-	isShuttingDown = true;
-	consola.info("\n🛑 Shutting down...");
-	for (const [pid, proc] of runningProcesses) if (!proc.killed) {
-		consola.info(`Terminating process ${pid}...`);
-		await killProcessTree(pid);
-	}
-	runningProcesses.clear();
-	for (const port of openPorts) await killPortProcesses(port);
-	openPorts.clear();
-	if (openPorts.size > 0 || runningProcesses.size > 0) {
-		consola.warn("Some processes may still be running, performing aggressive cleanup...");
-		await aggressiveCleanup();
-	}
-	if (watchHandle?.close) await watchHandle.close();
-	consola.success("✅ Shutdown complete\n");
-	process.exit(0);
-}
-const command = defineCommand({
-	meta: {
-		name: "dev",
-		description: "Start the development server for the project",
-		version
-	},
-	args: {
-		...commonArgs,
-		preset: {
-			type: "string",
-			description: "The build preset to use (you can also use `SILGI_PRESET` environment variable)."
-		},
-		stub: {
-			type: "boolean",
-			description: "Run in silgi development mode"
-		},
-		command: {
-			type: "string",
-			description: "Optional command to run alongside watch (e.g., \"npm run dev\")",
-			required: false
-		}
-	},
-	async run({ args, rawArgs }) {
-		await runCommand(prepare_default, { rawArgs: [
-			"--commandType",
-			"dev",
-			"--dev",
-			"true"
-		] });
-		watchHandle = await watchDev();
-		const userCommand = args.command || rawArgs[0];
-		if (userCommand) {
-			consola.withTag("silgi").info(`Starting: ${userCommand}`);
-			const [cmd, ...cmdArgs] = userCommand.split(" ");
-			if (!cmd) {
-				consola.error("Invalid command provided");
-				process.exit(1);
-			}
-			const childProcess = spawn(cmd, cmdArgs, {
-				stdio: [
-					"inherit",
-					"pipe",
-					"pipe"
-				],
-				cwd: process.cwd(),
-				shell: isWindows,
-				detached: !isWindows,
-				env: { ...process.env }
-			});
-			if (childProcess.pid) {
-				runningProcesses.set(childProcess.pid, childProcess);
-				consola.debug(`Started process ${childProcess.pid}`);
-			}
-			childProcess.stdout?.on("data", (data) => {
-				const output = data.toString();
-				process.stdout.write(output);
-				const port = detectPort(output);
-				if (port && !openPorts.has(port)) {
-					openPorts.add(port);
-					consola.info(`Detected server on port ${port}`);
-				}
-			});
-			childProcess.stderr?.on("data", (data) => {
-				process.stderr.write(data);
-			});
-			childProcess.on("exit", (code, signal) => {
-				if (childProcess.pid) runningProcesses.delete(childProcess.pid);
-				if (!isShuttingDown) {
-					if (code !== null && code !== 0) consola.error(`Process exited with code ${code}`);
-					else if (signal) consola.error(`Process killed by signal ${signal}`);
-					process.exit(code ?? 1);
-				}
-			});
-			childProcess.on("error", (err) => {
-				consola.error("Child process error:", err);
-				if (!isShuttingDown) process.exit(1);
-			});
-		}
-		consola.withTag("silgi").success("Prepare completed");
-		consola.withTag("silgi").info("Process is still running. Press Ctrl+C to exit.");
-		await new Promise(() => {});
-	}
-});
-process.on("SIGINT", shutdown);
-process.on("SIGTERM", shutdown);
-process.on("SIGHUP", shutdown);
-process.on("SIGQUIT", shutdown);
-process.on("exit", () => {
-	if (!isShuttingDown) for (const [pid] of runningProcesses) try {
-		process.kill(pid, "SIGKILL");
-	} catch {}
-});
-process.on("uncaughtException", (err) => {
-	consola.error("Uncaught exception:", err);
-	shutdown();
-});
-process.on("unhandledRejection", (err) => {
-	consola.error("Unhandled rejection:", err);
-	shutdown();
-});
-var watch_default = command;
-
-//#endregion
-export { watch_default as default };