sliftutils 0.6.6 → 0.7.1

package/builders/electronBuild.ts

@@ -0,0 +1,101 @@
+import fs from "fs";
+import { delay } from "socket-function/src/batching";
+import { bundleEntryCaller } from "../bundler/bundleEntryCaller";
+import yargs from "yargs";
+import { formatTime } from "socket-function/src/formatting/format";
+import path from "path";
+import { getAllFiles } from "../misc/fs";
+
+async function main() {
+    let time = Date.now();
+    let yargObj = yargs(process.argv)
+        .option("mainEntry", { type: "string", default: "./electron/electronMain.ts", desc: `Path to the main process entry point` })
+        .option("rendererEntry", { type: "string", default: "./electron/electronRenderer.tsx", desc: `Path to the renderer process entry point` })
+        .option("indexHtml", { type: "string", default: "./electron/electronIndex.html", desc: `Path to the index.html file` })
+        .option("assetsFolder", { type: "string", default: "./assets", desc: `Path to the assets folder` })
+        .option("outputFolder", { type: "string", default: "./build-electron", desc: `Output folder` })
+        .argv || {}
+        ;
+
+
+    // Wait for any async functions to load. 
+    await delay(0);
+
+    let hasMainEntry = fs.existsSync(yargObj.mainEntry);
+    let hasRendererEntry = fs.existsSync(yargObj.rendererEntry);
+    let hasIndexHtml = fs.existsSync(yargObj.indexHtml);
+    let hasAssets = fs.existsSync(yargObj.assetsFolder);
+
+    if (!hasMainEntry) {
+        throw new Error(`Main process entry point not found at ${yargObj.mainEntry}. Please specify with the --mainEntry option.`);
+    }
+    if (!hasRendererEntry) {
+        throw new Error(`Renderer process entry point not found at ${yargObj.rendererEntry}. Please specify with the --rendererEntry option.`);
+    }
+
+    await fs.promises.mkdir(yargObj.outputFolder, { recursive: true });
+
+    // Build main and renderer processes in parallel
+    await Promise.all([
+        bundleEntryCaller({
+            entryPoint: yargObj.mainEntry,
+            outputFolder: yargObj.outputFolder,
+        }),
+        bundleEntryCaller({
+            entryPoint: yargObj.rendererEntry,
+            outputFolder: yargObj.outputFolder,
+        })
+    ]);
+
+    // Collect all files to copy
+    let filesToCopy: string[] = [];
+
+    if (hasIndexHtml) {
+        filesToCopy.push(yargObj.indexHtml);
+    }
+
+    // Add assets folder files if it exists
+    if (hasAssets) {
+        for await (const file of getAllFiles(yargObj.assetsFolder)) {
+            filesToCopy.push(file);
+        }
+    }
+
+    // Copy all files with timestamp checking
+    async function getTimestamp(filePath: string): Promise<number> {
+        try {
+            const stats = await fs.promises.stat(filePath);
+            return stats.mtimeMs;
+        } catch (error) {
+            return 0;
+        }
+    }
+
+    let filesCopied = 0;
+    let root = path.resolve(".");
+    for (const file of filesToCopy) {
+        let sourcePath = path.resolve(file);
+        if (!fs.existsSync(sourcePath)) {
+            console.warn(`Warning: File not found: ${file}`);
+            continue;
+        }
+        let relativePath = path.relative(root, sourcePath);
+        let destPath = path.join(yargObj.outputFolder, relativePath);
+
+        let sourceTimestamp = await getTimestamp(sourcePath);
+        let destTimestamp = await getTimestamp(destPath);
+        if (sourceTimestamp > destTimestamp) {
+            await fs.promises.mkdir(path.dirname(destPath), { recursive: true });
+            await fs.promises.cp(sourcePath, destPath);
+            filesCopied++;
+        }
+    }
+    if (filesCopied > 0) {
+        console.log(`Copied ${filesCopied} changed files`);
+    }
+
+    let duration = Date.now() - time;
+    console.log(`Electron build completed in ${formatTime(duration)}`);
+}
+main().catch(console.error).finally(() => process.exit());
+

package/builders/electronBuildRun.js

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+require("typenode");
+require("./electronBuild.ts");
+

package/builders/extensionBuild.ts

@@ -13,9 +13,9 @@ async function main() {
     // And copy the manifest.json
     // AND copy everything in ./assets which has updated
     let yargObj = yargs(process.argv)
-        .option("backgroundEntry", { type: "string", default: "./extBackground.ts", desc: `Path to the entry point file` })
-        .option("contentEntry", { type: "string", default: "./extContentScript.ts", desc: `Path to the entry point file` })
-        .option("manifestPath", { type: "string", default: "./manifest.json", desc: `Path to the manifest.json file` })
+        .option("backgroundEntry", { type: "string", default: "./extension/extBackground.ts", desc: `Path to the entry point file` })
+        .option("contentEntry", { type: "string", default: "./extension/extContentScript.ts", desc: `Path to the entry point file` })
+        .option("manifestPath", { type: "string", default: "./extension/manifest.json", desc: `Path to the manifest.json file` })
         .option("assetsFolder", { type: "string", default: "./assets", desc: `Path to the assets folder` })
         .option("outputFolder", { type: "string", default: "./build-extension", desc: `Output folder` })
         .argv || {}
@@ -39,19 +39,25 @@ async function main() {
 
     await fs.promises.mkdir("./build-extension", { recursive: true });
 
+    // Build background and content scripts in parallel
+    let bundlePromises: Promise<void>[] = [];
     if (hasBackgroundEntry) {
-        await bundleEntryCaller({
+        bundlePromises.push(bundleEntryCaller({
             entryPoint: yargObj.backgroundEntry,
             outputFolder: yargObj.outputFolder,
-        });
+        }));
     }
     if (hasContentEntry) {
-        await bundleEntryCaller({
+        bundlePromises.push(bundleEntryCaller({
             entryPoint: yargObj.contentEntry,
             outputFolder: yargObj.outputFolder,
-        });
+        }));
     }
-    await fs.promises.cp(yargObj.manifestPath, path.join(yargObj.outputFolder, "manifest.json"));
+
+    await Promise.all([
+        ...bundlePromises,
+        fs.promises.cp(yargObj.manifestPath, path.join(yargObj.outputFolder, "manifest.json"))
+    ]);
 
     // Parse manifest and collect referenced files
     let manifestContent = await fs.promises.readFile(yargObj.manifestPath, "utf-8");
@@ -133,6 +139,6 @@ async function main() {
     }
 
     let duration = Date.now() - time;
-    console.log(`NodeJS build completed in ${formatTime(duration)}`);
+    console.log(`Extension build completed in ${formatTime(duration)}`);
 }
 main().catch(console.error).finally(() => process.exit());

package/builders/generateIndexDts.js

@@ -0,0 +1,46 @@
+const fs = require("fs");
+const path = require("path");
+
+function getAllDtsFiles(dir, fileList = []) {
+    const files = fs.readdirSync(dir);
+    
+    for (const file of files) {
+        const filePath = path.join(dir, file);
+        const stat = fs.statSync(filePath);
+        
+        if (stat.isDirectory()) {
+            getAllDtsFiles(filePath, fileList);
+        } else if (file.endsWith(".d.ts")) {
+            fileList.push(filePath);
+        }
+    }
+    
+    return fileList;
+}
+
+function generateIndexDts() {
+    const renderUtilsPath = path.join(__dirname, "..", "render-utils");
+    const dtsFiles = getAllDtsFiles(renderUtilsPath);
+    
+    const modules = dtsFiles
+        .map(filePath => {
+            const relativePath = path.relative(renderUtilsPath, filePath);
+            const withoutExt = relativePath.replace(/\.d\.ts$/, "");
+            const modulePath = "sliftutils/render-utils/" + withoutExt.replace(/\\/g, "/");
+            
+            const content = fs.readFileSync(filePath, "utf8");
+            
+            return `declare module "${modulePath}" {\n${content}\n}`;
+        })
+        .sort()
+        .join("\n\n");
+    
+    const outputPath = path.join(__dirname, "..", "index.d.ts");
+    const header = `// Auto-generated file. Do not edit manually.\n// Generated by: yarn generate-index-dts\n\n`;
+    
+    fs.writeFileSync(outputPath, header + modules + "\n", "utf8");
+    console.log(`Generated ${outputPath} with ${dtsFiles.length} module declarations`);
+}
+
+generateIndexDts();
+

package/builders/hotReload.ts

@@ -0,0 +1,96 @@
+import { isInBrowser, isInChromeExtension, isInChromeExtensionBackground, isInChromeExtensionContentScript } from "../misc/environment";
+
+const DEFAULT_WATCH_PORT = 9876;
+
+export async function enableHotReloading(config?: {
+    port?: number;
+}) {
+    if (isInChromeExtensionBackground()) {
+        chromeExtensionBackgroundHotReload(config?.port);
+    } else if (isInChromeExtensionContentScript()) {
+        chromeExtensionContentScriptHotReload();
+    } else if (typeof window !== "undefined" && typeof window.location && typeof window.location.reload === "function") {
+        // For most reloadable environments, just refresh
+        watchPortHotReload(config?.port, () => {
+            window.location.reload();
+        });
+    }
+}
+
+function watchPortHotReload(port = DEFAULT_WATCH_PORT, onReload: () => void) {
+    let reconnectTimer: number | undefined;
+    let ws: WebSocket | undefined;
+
+    let everConnected = false;
+
+    function connect() {
+        try {
+            ws = new WebSocket(`ws://localhost:${port}`);
+
+            ws.onopen = () => {
+                console.log(`[Hot Reload] Connected to watch server on port ${port}`);
+                everConnected = true;
+            };
+
+            ws.onmessage = (event) => {
+                try {
+                    let data = JSON.parse(event.data);
+                    if (data.type === "build-complete" && data.success) {
+                        console.log("[Hot Reload] Build complete, reloading page...");
+                        onReload();
+                    }
+                } catch (error) {
+                    console.error("[Hot Reload] Failed to parse message:", error);
+                }
+            };
+
+            ws.onerror = (error) => {
+                console.warn(`[Hot Reload] WebSocket error. Use the watch script to enable watching.`);
+            };
+
+            ws.onclose = () => {
+                if (everConnected) {
+                    console.log("[Hot Reload] Disconnected from watch server, reconnecting in 2s...");
+                    if (reconnectTimer) {
+                        clearTimeout(reconnectTimer);
+                    }
+                    reconnectTimer = setTimeout(() => {
+                        connect();
+                    }, 2000) as any;
+                }
+            };
+        } catch (error) {
+            console.error("[Hot Reload] Failed to connect:", error);
+        }
+    }
+
+    connect();
+}
+
+function chromeExtensionBackgroundHotReload(port = DEFAULT_WATCH_PORT) {
+    chrome.runtime.onConnect.addListener((port) => {
+        if (port.name === "hotReload") {
+            // Keep the port open so content scripts can detect when we disconnect
+        }
+    });
+
+    watchPortHotReload(port, () => {
+        chrome.runtime.reload();
+    });
+}
+
+function chromeExtensionContentScriptHotReload() {
+    let port = chrome.runtime.connect({ name: "hotReload" });
+
+    let startTime = Date.now();
+
+    port.onDisconnect.addListener(() => {
+        let timeToFail = Date.now() - startTime;
+        if (timeToFail > 10000) {
+            console.warn("[Hot Reload] Could not connect to background script. Make sure the background script calls enableHotReloading().");
+            return;
+        }
+        console.log("[Hot Reload] Extension reloaded, refreshing page...");
+        window.location.reload();
+    });
+}

package/builders/nodeJSBuild.ts

@@ -7,7 +7,7 @@ import { formatTime } from "socket-function/src/formatting/format";
 async function main() {
     let time = Date.now();
     let yargObj = yargs(process.argv)
-        .option("entryPoint", { type: "string", default: "./server.ts", desc: `Path to the entry point file` })
+        .option("entryPoint", { type: "string", default: "./nodejs/server.ts", desc: `Path to the entry point file` })
         .option("outputFolder", { type: "string", default: "./build-nodejs", desc: `Output folder` })
         .argv || {}
         ;

package/builders/setup.ts

@@ -0,0 +1,182 @@
+import fs from "fs";
+import path from "path";
+
+async function main() {
+    let targetDir = process.cwd();
+    let sourceDir = path.join(__dirname, "..");
+
+    console.log("Setting up sliftutils project...");
+    console.log(`Source: ${sourceDir}`);
+    console.log(`Target: ${targetDir}`);
+
+    // Directories and files to copy
+    let directoriesToScan = ["electron", "extension", "web", "nodejs", "assets", ".vscode"];
+    let rootFiles = [".cursorrules", ".eslintrc.js", ".gitignore", "tsconfig.json"];
+
+    // Import path mappings to convert relative imports to package imports
+    let importMappings: { [key: string]: string } = {
+        "../builders/": "sliftutils/builders/",
+        "../misc/": "sliftutils/misc/",
+        "../render-utils/": "sliftutils/render-utils/",
+        "../bundler/": "sliftutils/bundler/",
+        "../storage/": "sliftutils/storage/",
+    };
+
+    // Gather all files to copy
+    let filesToCopy: string[] = [];
+
+    // Add root files
+    for (let file of rootFiles) {
+        let sourcePath = path.join(sourceDir, file);
+        if (fs.existsSync(sourcePath)) {
+            filesToCopy.push(file);
+        }
+    }
+
+    // Gather files from directories
+    for (let dir of directoriesToScan) {
+        let sourcePath = path.join(sourceDir, dir);
+        if (fs.existsSync(sourcePath)) {
+            let filesInDir = gatherFilesRecursive(sourcePath, sourceDir);
+            filesToCopy.push(...filesInDir);
+        }
+    }
+
+    // Copy all files
+    console.log(`\nFound ${filesToCopy.length} files to copy\n`);
+
+    for (let relativePath of filesToCopy) {
+        let sourcePath = path.join(sourceDir, relativePath);
+        let targetPath = path.join(targetDir, relativePath);
+
+        // Check if target already exists
+        if (fs.existsSync(targetPath)) {
+            console.log(`Skipping ${relativePath} (already exists)`);
+            continue;
+        }
+
+        // Create directory if needed
+        let targetDirPath = path.dirname(targetPath);
+        if (!fs.existsSync(targetDirPath)) {
+            fs.mkdirSync(targetDirPath, { recursive: true });
+        }
+
+        // Copy file with import processing for .ts/.tsx files
+        if (relativePath.endsWith(".ts") || relativePath.endsWith(".tsx")) {
+            let content = fs.readFileSync(sourcePath, "utf8");
+            let processedContent = replaceImports(content, importMappings);
+            fs.writeFileSync(targetPath, processedContent, "utf8");
+            console.log(`Copied ${relativePath} (with import mapping)`);
+        } else {
+            fs.copyFileSync(sourcePath, targetPath);
+            console.log(`Copied ${relativePath}`);
+        }
+    }
+
+    // Update package.json with scripts
+    let packageJsonPath = path.join(targetDir, "package.json");
+    if (fs.existsSync(packageJsonPath)) {
+        console.log("\nUpdating package.json scripts...");
+        updatePackageJson(packageJsonPath);
+    } else {
+        console.warn("\nNo package.json found in target directory");
+    }
+
+    console.log("\nSetup complete!");
+}
+
+function gatherFilesRecursive(dir: string, baseDir: string): string[] {
+    let files: string[] = [];
+    let entries = fs.readdirSync(dir, { withFileTypes: true });
+
+    for (let entry of entries) {
+        let fullPath = path.join(dir, entry.name);
+
+        if (entry.isDirectory()) {
+            // Skip dist directories
+            if (entry.name === "dist") {
+                continue;
+            }
+            let subFiles = gatherFilesRecursive(fullPath, baseDir);
+            files.push(...subFiles);
+        } else {
+            // Add file as relative path from base directory
+            let relativePath = path.relative(baseDir, fullPath);
+            files.push(relativePath);
+        }
+    }
+
+    return files;
+}
+
+function replaceImports(content: string, importMappings: { [key: string]: string }): string {
+    let lines = content.split("\n");
+    let processedLines = lines.map(line => {
+        // Check if line contains an import or require statement
+        if (line.includes("import") || line.includes("require")) {
+            let processedLine = line;
+            for (let [oldPath, newPath] of Object.entries(importMappings)) {
+                processedLine = processedLine.replace(new RegExp(oldPath.replace(/\//g, "\\/"), "g"), newPath);
+            }
+            return processedLine;
+        }
+        return line;
+    });
+    return processedLines.join("\n");
+}
+
+function updatePackageJson(packageJsonPath: string) {
+    let packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf8"));
+
+    // Read our current package.json to get the type script
+    let sourcePackageJsonPath = path.join(__dirname, "..", "package.json");
+    let sourcePackageJson = JSON.parse(fs.readFileSync(sourcePackageJsonPath, "utf8"));
+
+    if (!packageJson.scripts) {
+        packageJson.scripts = {};
+    }
+
+    // Add type script (copied from source)
+    if (!packageJson.scripts.type) {
+        packageJson.scripts.type = sourcePackageJson.scripts.type;
+        console.log("  Added 'type' script");
+    }
+
+    // Copy run commands from source (except run-web)
+    let copiedCommands = ["run-nodejs", "run-nodejs-dev", "run-electron"];
+    for (let cmd of copiedCommands) {
+        if (!packageJson.scripts[cmd]) {
+            packageJson.scripts[cmd] = sourcePackageJson.scripts[cmd];
+            console.log(`  Added '${cmd}' script`);
+        }
+    }
+
+    // Add hard-coded commands
+    let hardCodedCommands: { [key: string]: string } = {
+        "run-web": "node ./node_modules/sliftutils/builders/webRun.js",
+        "build-nodejs": "build-nodejs",
+        "build-web": "build-web",
+        "build-extension": "build-extension",
+        "build-electron": "build-electron",
+        "watch-nodejs": "slift-watch --port 9876 \"nodejs/*.ts\" \"nodejs/*.tsx\" \"yarn build-nodejs\"",
+        "watch-web": "slift-watch --port 9877 \"web/*.ts\" \"web/*.tsx\" \"yarn build-web\"",
+        "watch-extension": "slift-watch --port 9878 \"extension/*.ts\" \"extension/*.tsx\" \"yarn build-extension\"",
+        "watch-electron": "slift-watch --port 9879 \"electron/*.ts\" \"electron/*.tsx\" \"yarn build-electron\"",
+    };
+
+    for (let [scriptName, command] of Object.entries(hardCodedCommands)) {
+        if (!packageJson.scripts[scriptName]) {
+            packageJson.scripts[scriptName] = command;
+            console.log(`  Added '${scriptName}' script`);
+        }
+    }
+
+    fs.writeFileSync(packageJsonPath, JSON.stringify(packageJson, undefined, 4) + "\n", "utf8");
+    console.log("  package.json updated");
+}
+
+main().catch(error => {
+    console.error("Setup failed:", error);
+    process.exit(1);
+});
+

package/builders/setupRun.js

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+require("typenode");
+require("./setup.ts");
+

package/builders/watch.ts

@@ -0,0 +1,182 @@
+import fs from "fs";
+import path from "path";
+import { runPromise } from "socket-function/src/runPromise";
+import { WebSocketServer } from "ws";
+
+const DEBOUNCE_DELAY_MS = 250;
+const DEFAULT_WATCH_PORT = 9876;
+
+async function main() {
+    let args = process.argv.slice(2);
+
+    if (args.length < 2) {
+        console.error("Usage: watch [--port PORT] <pattern1> [pattern2...] <command>");
+        console.error("Example: watch --port 9877 '*.ts' '*.tsx' 'yarn build'");
+        console.error("  - Patterns with wildcards must match the entire path");
+        console.error("  - Patterns without wildcards can appear anywhere in the path");
+        process.exit(1);
+    }
+
+    // Parse port parameter if present
+    let watchPort = DEFAULT_WATCH_PORT;
+    let argIndex = 0;
+
+    if (args[argIndex] === "--port") {
+        if (args.length < 4) {
+            console.error("--port requires a value");
+            process.exit(1);
+        }
+        watchPort = parseInt(args[argIndex + 1], 10);
+        if (isNaN(watchPort)) {
+            console.error(`Invalid port number: ${args[argIndex + 1]}`);
+            process.exit(1);
+        }
+        argIndex += 2;
+    }
+
+    let remainingArgs = args.slice(argIndex);
+    let patterns = remainingArgs.slice(0, -1);
+    let command = remainingArgs[remainingArgs.length - 1];
+
+    let currentDirectory = process.cwd();
+
+    // Setup WebSocket server (unless disabled with port <= 0)
+    let wss: WebSocketServer | undefined;
+    if (watchPort > 0) {
+        wss = new WebSocketServer({ port: watchPort });
+        console.log(`WebSocket server listening on port ${watchPort}. Use --port parameter to change this. Set it to 0 to disable watching.`);
+
+        wss.on("connection", (ws) => {
+            console.log(`[${new Date().toLocaleTimeString()}] WebSocket client connected`);
+            ws.on("close", () => {
+                console.log(`[${new Date().toLocaleTimeString()}] WebSocket client disconnected`);
+            });
+        });
+    } else {
+        console.log(`WebSocket server disabled (port <= 0)`);
+    }
+
+    console.log(`Watching patterns: ${patterns.join(", ")}`);
+    console.log(`Running command: ${command}`);
+    console.log("");
+
+    let debounceTimer: NodeJS.Timeout | undefined;
+    let isRunning = false;
+    let needsRerun = false;
+
+    async function executeCommand() {
+        if (isRunning) {
+            needsRerun = true;
+            return;
+        }
+
+        isRunning = true;
+        needsRerun = false;
+
+        try {
+            console.log(`\n[${new Date().toLocaleTimeString()}] Running: ${command}`);
+            await runPromise(command);
+            console.log(`[${new Date().toLocaleTimeString()}] Completed successfully`);
+
+            // Notify all connected WebSocket clients
+            if (wss) {
+                wss.clients.forEach((client) => {
+                    if (client.readyState === 1) { // 1 = OPEN
+                        client.send(JSON.stringify({ type: "build-complete", success: true }));
+                    }
+                });
+            }
+        } catch (error) {
+            console.error(`[${new Date().toLocaleTimeString()}] Error:`, error);
+
+            // Notify clients about build error
+            if (wss) {
+                wss.clients.forEach((client) => {
+                    if (client.readyState === 1) { // 1 = OPEN
+                        client.send(JSON.stringify({ type: "build-complete", success: false }));
+                    }
+                });
+            }
+        } finally {
+            isRunning = false;
+
+            if (needsRerun) {
+                console.log(`[${new Date().toLocaleTimeString()}] Detected changes during build, running again...`);
+                await executeCommand();
+            }
+        }
+    }
+
+    function scheduleRun() {
+        if (debounceTimer) {
+            clearTimeout(debounceTimer);
+        }
+
+        debounceTimer = setTimeout(() => {
+            void executeCommand();
+        }, DEBOUNCE_DELAY_MS);
+    }
+
+    function matchesPattern(filePath: string, pattern: string): boolean {
+        let relativePath = path.relative(currentDirectory, filePath).replace(/\\/g, "/").toLowerCase();
+        let lowerPattern = pattern.toLowerCase();
+
+        // If pattern contains wildcards, do full pattern matching
+        if (lowerPattern.includes("*")) {
+            // Convert wildcard pattern to regex
+            let regexPattern = lowerPattern
+                .replace(/\./g, "\\.") // Escape dots
+                .replace(/\*/g, ".*"); // * matches anything
+            let regex = new RegExp(`^${regexPattern}$`);
+            return regex.test(relativePath);
+        } else {
+            // No wildcards - pattern can appear anywhere in the path
+            return relativePath.includes(lowerPattern);
+        }
+    }
+
+    function shouldWatch(filePath: string): boolean {
+        for (let pattern of patterns) {
+            if (matchesPattern(filePath, pattern)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    function watchDirectory(dir: string) {
+        try {
+            let watcher = fs.watch(dir, { recursive: true }, (eventType, filename) => {
+                if (!filename) return;
+
+                let fullPath = path.join(dir, filename);
+
+                if (shouldWatch(fullPath)) {
+                    console.log(`[${new Date().toLocaleTimeString()}] Detected change: ${path.relative(currentDirectory, fullPath)}`);
+                    scheduleRun();
+                }
+            });
+
+            watcher.on("error", (error) => {
+                console.error(`Watch error for ${dir}:`, error);
+            });
+        } catch (error) {
+            console.error(`Failed to watch directory ${dir}:`, error);
+        }
+    }
+
+    // Start watching the current directory
+    watchDirectory(currentDirectory);
+
+    // Run the command once on startup
+    console.log("Initial build starting...");
+    await executeCommand();
+
+    console.log("\nWatching for changes... (Press Ctrl+C to exit)");
+}
+
+main().catch(error => {
+    console.error("Fatal error:", error);
+    process.exit(1);
+});
+

package/builders/watchRun.js

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+require("typenode");
+require("./watch.ts");
+