silgi 0.43.18 → 0.43.20

package/dist/cli/commands/run.mjs

@@ -7,7 +7,7 @@ import { runCommand } from "citty";
 const command = {
 	meta: {
 		name: "run",
-		description: "[DEPRECATED] Use \"silgi watch <command>\" instead",
+		description: "Run a command with silgi watch (shortcut for \"silgi watch npm run <command>\")",
 		version
 	},
 	args: { command: {
@@ -15,8 +15,13 @@ const command = {
 		description: "your application start command",
 		required: false
 	} },
-	async run({ rawArgs }) {
-		consola.warn("The \"run\" command is deprecated. Please use \"silgi watch <command>\" instead.");
+	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 });
 	}
 };

package/dist/cli/commands/watch.mjs

@@ -1,14 +1,52 @@
 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 { execa } from "execa";
-import psTree from "ps-tree";
-import treeKill from "tree-kill";
+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",
@@ -38,9 +76,8 @@ const command = defineCommand({
 			"--dev",
 			"true"
 		] });
-		const watch = await watchDev();
+		watchHandle = await watchDev();
 		const userCommand = args.command || rawArgs[0];
-		let childProcess = null;
 		if (userCommand) {
 			consola.withTag("silgi").info(`Starting: ${userCommand}`);
 			const [cmd, ...cmdArgs] = userCommand.split(" ");
@@ -48,82 +85,68 @@ const command = defineCommand({
 				consola.error("Invalid command provided");
 				process.exit(1);
 			}
-			childProcess = execa(cmd, cmdArgs, {
-				stdio: "inherit",
+			const childProcess = spawn(cmd, cmdArgs, {
+				stdio: [
+					"inherit",
+					"pipe",
+					"pipe"
+				],
 				cwd: process.cwd(),
-				cleanup: true,
-				detached: false
+				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) => {
-				if (code !== 0) consola.error(`Process exited with code ${code}`);
-				process.exit(code ?? 0);
+			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);
-				process.exit(1);
+				if (!isShuttingDown) process.exit(1);
 			});
 		}
-		let isShuttingDown = false;
-		const shutdown = async (signal) => {
-			if (isShuttingDown) return;
-			isShuttingDown = true;
-			consola.withTag("silgi").info(`Received ${signal}, shutting down...`);
-			try {
-				if (childProcess && childProcess.pid) {
-					const children = await new Promise((resolve) => {
-						psTree(childProcess.pid, (err, children$1) => {
-							if (err) resolve([]);
-							else resolve(children$1);
-						});
-					});
-					if (children.length > 0) {
-						consola.info("Terminating process tree:");
-						children.forEach((child) => {
-							consola.info(`  - ${child.COMMAND} (PID: ${child.PID})`);
-						});
-					}
-					const processCount = children.length + 1;
-					consola.info(`Terminating ${processCount} processes...`);
-					await new Promise((resolve) => {
-						treeKill(childProcess.pid, "SIGTERM", (err) => {
-							if (err) consola.withTag("silgi").error("Error killing process tree:", err);
-							resolve();
-						});
-					});
-					await new Promise((resolve) => setTimeout(resolve, 2e3));
-					if (childProcess.pid) try {
-						treeKill(childProcess.pid, "SIGKILL");
-					} catch {}
-				}
-				if (watch?.close) await watch.close();
-				consola.success("All processes terminated successfully");
-			} catch (error) {
-				consola.withTag("silgi").error("Error during shutdown:", error);
-			}
-			process.exit(0);
-		};
-		process.on("SIGINT", () => shutdown("SIGINT"));
-		process.on("SIGTERM", () => shutdown("SIGTERM"));
-		process.on("SIGHUP", () => shutdown("SIGHUP"));
-		process.on("SIGQUIT", () => shutdown("SIGQUIT"));
-		process.on("exit", () => {
-			if (childProcess && childProcess.pid) try {
-				treeKill(childProcess.pid, "SIGKILL");
-			} catch {}
-		});
-		process.on("uncaughtException", (error) => {
-			consola.withTag("silgi").error("Uncaught exception:", error);
-			shutdown("uncaughtException");
-		});
-		process.on("unhandledRejection", (reason, promise) => {
-			consola.withTag("silgi").error("Unhandled rejection at:", promise, "reason:", reason);
-			shutdown("unhandledRejection");
-		});
 		consola.withTag("silgi").success("Prepare completed");
 		consola.withTag("silgi").info("Process is still running. Press Ctrl+C to exit.");
-		if (!childProcess) await new Promise(() => {});
+		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

package/dist/cli/utils/processManager.mjs

@@ -0,0 +1,170 @@
+import consola from "consola";
+import { execSync } from "node:child_process";
+
+//#region src/cli/utils/processManager.ts
+const isWindows = process.platform === "win32";
+/**
+* Get all processes using a specific port
+*/
+async function getProcessesOnPort(port) {
+	const processes = [];
+	try {
+		if (isWindows) {
+			const output = execSync("netstat -ano", { encoding: "utf8" });
+			const lines = output.split("\n");
+			for (const line of lines) if (line.includes(`:${port}`) && line.includes("LISTENING")) {
+				const parts = line.trim().split(/\s+/);
+				const pidStr = parts[parts.length - 1];
+				if (!pidStr) continue;
+				const pid = Number.parseInt(pidStr);
+				if (pid && pid !== 0 && !Number.isNaN(pid)) try {
+					const taskList = execSync(`tasklist /FI "PID eq ${pid}" /FO CSV`, { encoding: "utf8" });
+					const lines$1 = taskList.split("\n");
+					const processLine = lines$1[1];
+					if (processLine) {
+						const namePart = processLine.split(",")[0];
+						if (namePart) {
+							const name = namePart.replace(/"/g, "");
+							processes.push({
+								pid,
+								name,
+								port
+							});
+						}
+					}
+				} catch {
+					processes.push({
+						pid,
+						name: "unknown",
+						port
+					});
+				}
+			}
+		} else try {
+			const output = execSync(`lsof -i:${port} -P -n`, { encoding: "utf8" });
+			const lines = output.split("\n").slice(1);
+			for (const line of lines) if (line.trim()) {
+				const parts = line.trim().split(/\s+/);
+				const name = parts[0];
+				const pidStr = parts[1];
+				if (!name || !pidStr) continue;
+				const pid = Number.parseInt(pidStr);
+				if (pid && !Number.isNaN(pid) && !processes.some((p) => p.pid === pid)) processes.push({
+					pid,
+					name,
+					port
+				});
+			}
+		} catch {}
+	} catch (error) {
+		consola.debug(`Failed to get processes on port ${port}:`, error);
+	}
+	return processes;
+}
+/**
+* Kill a process and all its children
+*/
+async function killProcessTree(pid, signal = "SIGKILL") {
+	try {
+		if (isWindows) {
+			execSync(`taskkill /F /T /PID ${pid}`, { stdio: "ignore" });
+			return true;
+		} else try {
+			process.kill(-pid, signal);
+			return true;
+		} catch {
+			process.kill(pid, signal);
+			return true;
+		}
+	} catch (error) {
+		consola.debug(`Failed to kill process ${pid}:`, error);
+		return false;
+	}
+}
+/**
+* Kill all processes on a specific port
+*/
+async function killPortProcesses(port) {
+	const processes = await getProcessesOnPort(port);
+	let killedCount = 0;
+	for (const proc of processes) {
+		consola.info(`Killing ${proc.name} (PID: ${proc.pid}) on port ${port}`);
+		if (await killProcessTree(proc.pid)) killedCount++;
+	}
+	return killedCount;
+}
+/**
+* Find and kill all Node.js processes in a directory
+*/
+async function killNodeProcessesInDirectory(directory) {
+	let killedCount = 0;
+	try {
+		if (isWindows) {
+			const output = execSync("wmic process where \"name='node.exe'\" get ProcessId,CommandLine /FORMAT:CSV", {
+				encoding: "utf8",
+				stdio: [
+					"ignore",
+					"pipe",
+					"ignore"
+				]
+			});
+			const lines = output.split("\n");
+			for (const line of lines) if (line.includes(directory)) {
+				const parts = line.split(",");
+				const pidStr = parts[parts.length - 1];
+				if (!pidStr) continue;
+				const pid = Number.parseInt(pidStr);
+				if (pid && !Number.isNaN(pid)) {
+					consola.info(`Killing node process ${pid} in ${directory}`);
+					if (await killProcessTree(pid)) killedCount++;
+				}
+			}
+		} else {
+			const output = execSync("ps aux", { encoding: "utf8" });
+			const lines = output.split("\n");
+			for (const line of lines) if (line.includes("node") && line.includes(directory)) {
+				const parts = line.trim().split(/\s+/);
+				const pidStr = parts[1];
+				if (!pidStr) continue;
+				const pid = Number.parseInt(pidStr);
+				if (pid && !Number.isNaN(pid)) {
+					consola.info(`Killing node process ${pid} in ${directory}`);
+					if (await killProcessTree(pid)) killedCount++;
+				}
+			}
+		}
+	} catch (error) {
+		consola.debug("Failed to find node processes:", error);
+	}
+	return killedCount;
+}
+/**
+* Aggressive cleanup: kill all processes on common dev ports
+*/
+async function aggressiveCleanup() {
+	const commonPorts = [
+		3e3,
+		3001,
+		4e3,
+		5e3,
+		5173,
+		8080,
+		8e3,
+		9e3
+	];
+	consola.info("Performing aggressive cleanup...");
+	for (const port of commonPorts) {
+		const processes = await getProcessesOnPort(port);
+		if (processes.length > 0) {
+			consola.info(`Found ${processes.length} process(es) on port ${port}`);
+			await killPortProcesses(port);
+		}
+	}
+	const cwd = process.cwd();
+	const killedInDir = await killNodeProcessesInDirectory(cwd);
+	if (killedInDir > 0) consola.info(`Killed ${killedInDir} node process(es) in ${cwd}`);
+	consola.success("Aggressive cleanup complete");
+}
+
+//#endregion
+export { aggressiveCleanup, killPortProcesses, killProcessTree };

package/dist/package.mjs

@@ -1,7 +1,7 @@
 //#region package.json
 var name = "silgi";
 var type = "module";
-var version = "0.43.18";
+var version = "0.43.20";
 var private$1 = false;
 var packageManager = "pnpm@10.12.4";
 var sideEffects = false;
@@ -107,7 +107,6 @@ var dependencies = {
 	"perfect-debounce": "^1.0.0",
 	"picocolors": "catalog:",
 	"pkg-types": "catalog:",
-	"ps-tree": "^1.2.0",
 	"rfc6902": "^5.1.2",
 	"rou3": "^0.7.3",
 	"scule": "catalog:",
@@ -115,7 +114,6 @@ var dependencies = {
 	"srvx": "^0.8.2",
 	"std-env": "catalog:",
 	"tinyglobby": "^0.2.14",
-	"tree-kill": "^1.2.2",
 	"ufo": "catalog:",
 	"unadapter": "^0.1.2",
 	"unctx": "catalog:",
@@ -130,11 +128,10 @@ var devDependencies = {
 	"@silgi/ecosystem": "catalog:",
 	"@types/micromatch": "^4.0.9",
 	"@types/node": "catalog:",
-	"@types/ps-tree": "^1.1.6",
 	"@types/semver": "catalog:",
 	"@vitest/coverage-v8": "catalog:",
 	"eslint": "catalog:",
-	"h3": "^2.0.0-beta.1",
+	"h3": "catalog:",
 	"nitropack": "catalog:",
 	"nuxt": "catalog:",
 	"tsdown": "^0.12.9",

package/dist/types/kits.d.mts

@@ -1,9 +1,9 @@
 import { SilgiCLI } from "./silgiCLI.mjs";
 import { BuildSilgi } from "./silgi.mjs";
 import { ESMCodeGenOptions, ESMImport } from "knitwork";
-import * as h33 from "h3";
+import * as h32 from "h3";
 import { PresetName } from "silgi/presets";
-import * as nitropack_types1 from "nitropack/types";
+import * as nitropack_types0 from "nitropack/types";
 
 //#region src/types/kits.d.ts
 interface SilgiCommands {}
@@ -24,7 +24,7 @@ interface GenImport {
   imports: ESMImport | ESMImport[];
   options?: ESMCodeGenOptions;
 }
-type Framework<T extends PresetName> = T extends "nitro" ? nitropack_types1.NitroApp : T extends "nuxt" ? nitropack_types1.NitroApp : T extends "h3" ? h33.Router : never;
+type Framework<T extends PresetName> = T extends "nitro" ? nitropack_types0.NitroApp : T extends "nuxt" ? nitropack_types0.NitroApp : T extends "h3" ? h32.Router : never;
 interface DefineFrameworkOptions<T extends PresetName> extends Omit<BuildSilgi, "framework"> {
   framework: Framework<T>;
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "silgi",
   "type": "module",
-  "version": "0.43.18",
+  "version": "0.43.20",
   "private": false,
   "sideEffects": false,
   "exports": {
@@ -116,7 +116,6 @@
     "perfect-debounce": "^1.0.0",
     "picocolors": "^1.1.1",
     "pkg-types": "^2.2.0",
-    "ps-tree": "^1.2.0",
     "rfc6902": "^5.1.2",
     "rou3": "^0.7.3",
     "scule": "^1.3.0",
@@ -124,7 +123,6 @@
     "srvx": "^0.8.2",
     "std-env": "^3.9.0",
     "tinyglobby": "^0.2.14",
-    "tree-kill": "^1.2.2",
     "ufo": "^1.6.1",
     "unadapter": "^0.1.2",
     "unctx": "^2.4.1",
@@ -139,11 +137,10 @@
     "@silgi/ecosystem": "^0.7.3",
     "@types/micromatch": "^4.0.9",
     "@types/node": "^24.0.10",
-    "@types/ps-tree": "^1.1.6",
     "@types/semver": "^7.7.0",
     "@vitest/coverage-v8": "3.0.5",
     "eslint": "^9.30.1",
-    "h3": "^2.0.0-beta.1",
+    "h3": "^1.15.3",
     "nitropack": "^2.11.13",
     "nuxt": "^3.17.6",
     "tsdown": "^0.12.9",