@fgv/ts-res-browser-cli 5.0.0-2

package/lib/zipArchiver.d.ts

@@ -0,0 +1,35 @@
+import { Result } from '@fgv/ts-utils';
+export interface ZipArchiveOptions {
+    input?: string;
+    config?: string;
+    outputDir?: string;
+}
+export interface ZipArchiveResult {
+    zipPath: string;
+    manifest: ZipManifest;
+}
+export interface ZipManifest {
+    timestamp: string;
+    input?: {
+        type: 'file' | 'directory';
+        originalPath: string;
+        archivePath: string;
+    };
+    config?: {
+        type: 'file';
+        originalPath: string;
+        archivePath: string;
+    };
+}
+export declare class ZipArchiver {
+    /**
+     * Create a ZIP archive containing the specified input and config files/directories
+     */
+    createArchive(options: ZipArchiveOptions): Promise<Result<ZipArchiveResult>>;
+    /**
+     * Get the default downloads directory path
+     */
+    getDefaultDownloadsDir(): string;
+}
+export declare const zipArchiver: ZipArchiver;
+//# sourceMappingURL=zipArchiver.d.ts.map

package/lib/zipArchiver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"zipArchiver.d.ts","sourceRoot":"","sources":["../src/zipArchiver.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,MAAM,EAAiB,MAAM,eAAe,CAAC;AAEtD,MAAM,WAAW,iBAAiB;IAChC,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,gBAAgB;IAC/B,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,WAAW,CAAC;CACvB;AAED,MAAM,WAAW,WAAW;IAC1B,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,CAAC,EAAE;QACN,IAAI,EAAE,MAAM,GAAG,WAAW,CAAC;QAC3B,YAAY,EAAE,MAAM,CAAC;QACrB,WAAW,EAAE,MAAM,CAAC;KACrB,CAAC;IACF,MAAM,CAAC,EAAE;QACP,IAAI,EAAE,MAAM,CAAC;QACb,YAAY,EAAE,MAAM,CAAC;QACrB,WAAW,EAAE,MAAM,CAAC;KACrB,CAAC;CACH;AAED,qBAAa,WAAW;IACtB;;OAEG;IACG,aAAa,CAAC,OAAO,EAAE,iBAAiB,GAAG,OAAO,CAAC,MAAM,CAAC,gBAAgB,CAAC,CAAC;IA4GlF;;OAEG;IACH,sBAAsB,IAAI,MAAM;CAGjC;AAGD,eAAO,MAAM,WAAW,aAAoB,CAAC"}

package/lib/zipArchiver.js

@@ -0,0 +1,148 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.zipArchiver = exports.ZipArchiver = void 0;
+const archiver = __importStar(require("archiver"));
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const ts_utils_1 = require("@fgv/ts-utils");
+class ZipArchiver {
+    /**
+     * Create a ZIP archive containing the specified input and config files/directories
+     */
+    async createArchive(options) {
+        try {
+            const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+            const outputDir = options.outputDir || path.join(os.homedir(), 'Downloads');
+            const zipFileName = `ts-res-bundle-${timestamp}.zip`;
+            const zipPath = path.join(outputDir, zipFileName);
+            // Ensure output directory exists
+            if (!fs.existsSync(outputDir)) {
+                fs.mkdirSync(outputDir, { recursive: true });
+            }
+            const output = fs.createWriteStream(zipPath);
+            const archive = archiver.create('zip', {
+                zlib: { level: 6 } // Good compression level
+            });
+            // Create manifest
+            const manifest = {
+                timestamp: new Date().toISOString()
+            };
+            // Promise to handle async archiving
+            const archivePromise = new Promise((resolve, reject) => {
+                output.on('close', () => {
+                    resolve();
+                });
+                output.on('error', (err) => {
+                    reject(err);
+                });
+                archive.on('error', (err) => {
+                    reject(err);
+                });
+            });
+            // Pipe archive data to the file
+            archive.pipe(output);
+            // Add input files/directory
+            if (options.input) {
+                const inputPath = path.resolve(options.input);
+                if (!fs.existsSync(inputPath)) {
+                    return (0, ts_utils_1.fail)(`Input path does not exist: ${inputPath}`);
+                }
+                const stats = fs.statSync(inputPath);
+                if (stats.isDirectory()) {
+                    // Add entire directory recursively, preserving structure
+                    const dirName = path.basename(inputPath);
+                    archive.directory(inputPath, `input/${dirName}`);
+                    manifest.input = {
+                        type: 'directory',
+                        originalPath: inputPath,
+                        archivePath: `input/${dirName}`
+                    };
+                }
+                else if (stats.isFile()) {
+                    // Add single file
+                    const fileName = path.basename(inputPath);
+                    archive.file(inputPath, { name: `input/${fileName}` });
+                    manifest.input = {
+                        type: 'file',
+                        originalPath: inputPath,
+                        archivePath: `input/${fileName}`
+                    };
+                }
+            }
+            // Add config file
+            if (options.config) {
+                const configPath = path.resolve(options.config);
+                if (!fs.existsSync(configPath)) {
+                    return (0, ts_utils_1.fail)(`Config file does not exist: ${configPath}`);
+                }
+                const stats = fs.statSync(configPath);
+                if (!stats.isFile()) {
+                    return (0, ts_utils_1.fail)(`Config path must be a file: ${configPath}`);
+                }
+                const fileName = path.basename(configPath);
+                archive.file(configPath, { name: `config/${fileName}` });
+                manifest.config = {
+                    type: 'file',
+                    originalPath: configPath,
+                    archivePath: `config/${fileName}`
+                };
+            }
+            // Add manifest
+            archive.append(JSON.stringify(manifest, null, 2), { name: 'manifest.json' });
+            // Finalize the archive
+            await archive.finalize();
+            await archivePromise;
+            return (0, ts_utils_1.succeed)({
+                zipPath,
+                manifest
+            });
+        }
+        catch (error) {
+            return (0, ts_utils_1.fail)(`Failed to create ZIP archive: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    /**
+     * Get the default downloads directory path
+     */
+    getDefaultDownloadsDir() {
+        return path.join(os.homedir(), 'Downloads');
+    }
+}
+exports.ZipArchiver = ZipArchiver;
+// Export singleton instance
+exports.zipArchiver = new ZipArchiver();
+//# sourceMappingURL=zipArchiver.js.map

package/lib/zipArchiver.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"zipArchiver.js","sourceRoot":"","sources":["../src/zipArchiver.ts"],"names":[],"mappings":"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","sourcesContent":["import * as archiver from 'archiver';\nimport * as fs from 'fs';\nimport * as path from 'path';\nimport * as os from 'os';\nimport { Result, succeed, fail } from '@fgv/ts-utils';\n\nexport interface ZipArchiveOptions {\n  input?: string;\n  config?: string;\n  outputDir?: string;\n}\n\nexport interface ZipArchiveResult {\n  zipPath: string;\n  manifest: ZipManifest;\n}\n\nexport interface ZipManifest {\n  timestamp: string;\n  input?: {\n    type: 'file' | 'directory';\n    originalPath: string;\n    archivePath: string;\n  };\n  config?: {\n    type: 'file';\n    originalPath: string;\n    archivePath: string;\n  };\n}\n\nexport class ZipArchiver {\n  /**\n   * Create a ZIP archive containing the specified input and config files/directories\n   */\n  async createArchive(options: ZipArchiveOptions): Promise<Result<ZipArchiveResult>> {\n    try {\n      const timestamp = new Date().toISOString().replace(/[:.]/g, '-');\n      const outputDir = options.outputDir || path.join(os.homedir(), 'Downloads');\n      const zipFileName = `ts-res-bundle-${timestamp}.zip`;\n      const zipPath = path.join(outputDir, zipFileName);\n\n      // Ensure output directory exists\n      if (!fs.existsSync(outputDir)) {\n        fs.mkdirSync(outputDir, { recursive: true });\n      }\n\n      const output = fs.createWriteStream(zipPath);\n      const archive = archiver.create('zip', {\n        zlib: { level: 6 } // Good compression level\n      });\n\n      // Create manifest\n      const manifest: ZipManifest = {\n        timestamp: new Date().toISOString()\n      };\n\n      // Promise to handle async archiving\n      const archivePromise = new Promise<void>((resolve, reject) => {\n        output.on('close', () => {\n          resolve();\n        });\n\n        output.on('error', (err: Error) => {\n          reject(err);\n        });\n\n        archive.on('error', (err: Error) => {\n          reject(err);\n        });\n      });\n\n      // Pipe archive data to the file\n      archive.pipe(output);\n\n      // Add input files/directory\n      if (options.input) {\n        const inputPath = path.resolve(options.input);\n\n        if (!fs.existsSync(inputPath)) {\n          return fail(`Input path does not exist: ${inputPath}`);\n        }\n\n        const stats = fs.statSync(inputPath);\n        if (stats.isDirectory()) {\n          // Add entire directory recursively, preserving structure\n          const dirName = path.basename(inputPath);\n          archive.directory(inputPath, `input/${dirName}`);\n          manifest.input = {\n            type: 'directory',\n            originalPath: inputPath,\n            archivePath: `input/${dirName}`\n          };\n        } else if (stats.isFile()) {\n          // Add single file\n          const fileName = path.basename(inputPath);\n          archive.file(inputPath, { name: `input/${fileName}` });\n          manifest.input = {\n            type: 'file',\n            originalPath: inputPath,\n            archivePath: `input/${fileName}`\n          };\n        }\n      }\n\n      // Add config file\n      if (options.config) {\n        const configPath = path.resolve(options.config);\n\n        if (!fs.existsSync(configPath)) {\n          return fail(`Config file does not exist: ${configPath}`);\n        }\n\n        const stats = fs.statSync(configPath);\n        if (!stats.isFile()) {\n          return fail(`Config path must be a file: ${configPath}`);\n        }\n\n        const fileName = path.basename(configPath);\n        archive.file(configPath, { name: `config/${fileName}` });\n        manifest.config = {\n          type: 'file',\n          originalPath: configPath,\n          archivePath: `config/${fileName}`\n        };\n      }\n\n      // Add manifest\n      archive.append(JSON.stringify(manifest, null, 2), { name: 'manifest.json' });\n\n      // Finalize the archive\n      await archive.finalize();\n      await archivePromise;\n\n      return succeed({\n        zipPath,\n        manifest\n      });\n    } catch (error) {\n      return fail(`Failed to create ZIP archive: ${error instanceof Error ? error.message : String(error)}`);\n    }\n  }\n\n  /**\n   * Get the default downloads directory path\n   */\n  getDefaultDownloadsDir(): string {\n    return path.join(os.homedir(), 'Downloads');\n  }\n}\n\n// Export singleton instance\nexport const zipArchiver = new ZipArchiver();\n"]}

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "@fgv/ts-res-browser-cli",
+  "version": "5.0.0-2",
+  "description": "Command-line interface to launch ts-res-browser with specified options",
+  "main": "lib/index.js",
+  "types": "lib/index.d.ts",
+  "bin": {
+    "ts-res-browser-cli": "bin/ts-res-browser-cli.js"
+  },
+  "keywords": [
+    "ts-res",
+    "browser",
+    "cli",
+    "tool",
+    "resource",
+    "visualization"
+  ],
+  "author": "Erik Fortune",
+  "license": "MIT",
+  "engines": {
+    "node": ">=20.0.0"
+  },
+  "dependencies": {
+    "commander": "^11.0.0",
+    "archiver": "~7.0.1",
+    "@types/archiver": "~6.0.3",
+    "@fgv/ts-res": "5.0.0-2",
+    "@fgv/ts-json": "5.0.0-2",
+    "@fgv/ts-utils": "5.0.0-2",
+    "@fgv/ts-json-base": "5.0.0-2"
+  },
+  "devDependencies": {
+    "@rushstack/heft": "~0.74.0",
+    "@rushstack/heft-node-rig": "~2.9.0",
+    "@types/jest": "^29.5.14",
+    "@types/node": "^20.14.9",
+    "eslint": "^8.57.0",
+    "jest": "^29.7.0",
+    "typescript": "^5.7.3",
+    "@fgv/ts-utils-jest": "5.0.0-2"
+  },
+  "scripts": {
+    "build": "heft build --clean",
+    "test": "heft test --clean",
+    "clean": "heft clean",
+    "lint": "eslint src --ext .ts",
+    "fixlint": "eslint src --ext .ts --fix"
+  }
+}

package/rush-logs/ts-res-browser-cli.build.cache.log

@@ -0,0 +1,3 @@
+Caching build output folders: lib, .rush/temp/operation/build
+Successfully set cache entry.
+Cache key: 45629f175c0b2c015132e9451c317583db1c0e2d

package/rush-logs/ts-res-browser-cli.build.log

@@ -0,0 +1,5 @@
+Invoking: heft build --clean 
+ ---- build started ---- 
+[build:typescript] Using TypeScript version 5.8.3
+ ---- build finished (4.946s) ---- 
+-------------------- Finished (4.952s) --------------------

package/src/browserLauncher.ts

@@ -0,0 +1,366 @@
+/*
+ * Copyright (c) 2025 Erik Fortune
+ *
+ * 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.
+ */
+
+import { exec, spawn, ChildProcess } from 'child_process';
+import * as path from 'path';
+import * as http from 'http';
+import { Result, succeed, fail } from '@fgv/ts-utils';
+import { IBrowseOptions } from './options';
+import { zipArchiver } from './zipArchiver';
+import * as fs from 'fs';
+
+/**
+ * Manages launching the browser application with specified options
+ */
+export class BrowserLauncher {
+  private _devServer?: ChildProcess;
+  /**
+   * Launches the browser with the specified options
+   */
+  public async launch(options: IBrowseOptions): Promise<Result<void>> {
+    try {
+      // Check if we need to create a ZIP archive for file-based inputs
+      let zipCreated = false;
+      let finalOptions = { ...options };
+
+      if (this._shouldCreateZip(options)) {
+        if (!options.quiet) {
+          console.log('Creating ZIP archive for file-based resources...');
+        }
+
+        const zipResult = await this._createZipArchive(options);
+        if (zipResult.isFailure()) {
+          return fail(`Failed to create ZIP archive: ${zipResult.message}`);
+        }
+
+        if (!options.quiet) {
+          console.log(`ZIP archive created: ${zipResult.value.zipPath}`);
+        }
+
+        // Modify options to use ZIP loading instead of file paths
+        const zipFileName = path.basename(zipResult.value.zipPath);
+        finalOptions = {
+          ...options,
+          input: undefined,
+          config: undefined,
+          // Add ZIP loading parameters
+          loadZip: true,
+          zipFile: zipFileName,
+          zipPath: zipResult.value.zipPath
+        };
+        zipCreated = true;
+      }
+
+      // Start development server if requested
+      if (finalOptions.dev && !finalOptions.url) {
+        if (!finalOptions.quiet) {
+          console.log('Starting TS-RES Browser development server...');
+        }
+
+        const serverResult = await this._startDevServer(finalOptions);
+        if (serverResult.isFailure()) {
+          return serverResult;
+        }
+
+        // Wait for server to be ready
+        const port = options.port || 3000;
+        const readyResult = await this._waitForServerReady(port, options.verbose || false);
+        if (readyResult.isFailure()) {
+          this._stopDevServer();
+          return readyResult;
+        }
+
+        if (!options.quiet) {
+          console.log(`Development server started on port ${port}`);
+        }
+      }
+
+      // Build URL with parameters
+      const url = this._buildUrl(finalOptions);
+
+      if (!finalOptions.quiet) {
+        console.log('Opening TS-RES Browser...');
+        if (zipCreated) {
+          console.log('ZIP archive created - browser will load from Downloads folder');
+        } else {
+          if (finalOptions.input) {
+            console.log(`Resource file: ${finalOptions.input}`);
+          }
+          if (finalOptions.config) {
+            console.log(`Configuration: ${finalOptions.config}`);
+          }
+        }
+        if (finalOptions.contextFilter) {
+          console.log(`Context filter: ${finalOptions.contextFilter}`);
+        }
+        console.log(`URL: ${url}`);
+      }
+
+      // Open browser if requested (default to true)
+      const shouldOpen = finalOptions.open !== false;
+      if (shouldOpen) {
+        const openResult = await this._openBrowser(url, finalOptions.verbose || false);
+        if (openResult.isFailure()) {
+          return fail(`Could not open browser: ${openResult.message}`);
+        }
+
+        if (!finalOptions.quiet) {
+          console.log('Browser opened successfully');
+        }
+      } else {
+        console.log(`Browser URL: ${url}`);
+      }
+
+      return succeed(undefined);
+    } catch (error) {
+      return fail(`Failed to launch browser: ${error}`);
+    }
+  }
+
+  /**
+   * Opens the browser to the specified URL
+   */
+  private async _openBrowser(url: string, verbose: boolean): Promise<Result<void>> {
+    return new Promise((resolve) => {
+      const command =
+        process.platform === 'darwin' ? 'open' : process.platform === 'win32' ? 'start ""' : 'xdg-open';
+
+      exec(`${command} "${url}"`, (error) => {
+        if (error) {
+          resolve(fail(`Failed to open browser: ${error.message}`));
+        } else {
+          if (verbose) {
+            console.log(`Opened browser to: ${url}`);
+          }
+          resolve(succeed(undefined));
+        }
+      });
+    });
+  }
+
+  /**
+   * Builds the URL with query parameters based on options
+   */
+  private _buildUrl(options: IBrowseOptions): string {
+    // Use provided URL or default to localhost
+    const baseUrl = options.url || `http://localhost:${options.port || 3000}`;
+    const params = new URLSearchParams();
+
+    if (options.input) {
+      params.set('input', options.input);
+    }
+
+    if (options.config) {
+      params.set('config', options.config);
+    }
+
+    if (options.contextFilter) {
+      params.set('contextFilter', options.contextFilter);
+    }
+
+    if (options.qualifierDefaults) {
+      params.set('qualifierDefaults', options.qualifierDefaults);
+    }
+
+    if (options.resourceTypes) {
+      params.set('resourceTypes', options.resourceTypes);
+    }
+
+    if (options.maxDistance !== undefined) {
+      params.set('maxDistance', options.maxDistance.toString());
+    }
+
+    if (options.reduceQualifiers) {
+      params.set('reduceQualifiers', 'true');
+    }
+
+    if (options.interactive) {
+      params.set('interactive', 'true');
+    }
+
+    if (options.loadZip) {
+      params.set('loadZip', 'true');
+    }
+
+    if (options.zipFile) {
+      params.set('zipFile', options.zipFile);
+    }
+
+    if (options.zipPath) {
+      params.set('zipPath', options.zipPath);
+    }
+
+    const queryString = params.toString();
+    return queryString ? `${baseUrl}?${queryString}` : baseUrl;
+  }
+
+  /**
+   * Starts the development server for ts-res-browser
+   */
+  private async _startDevServer(options: IBrowseOptions): Promise<Result<void>> {
+    try {
+      // Find the ts-res-browser project directory
+      // Assume we're running from tools/ts-res-browser-cli, so go up and over to tools/ts-res-browser
+      const browserProjectPath = path.resolve(__dirname, '../../ts-res-browser');
+
+      if (options.verbose) {
+        console.log(`Looking for ts-res-browser at: ${browserProjectPath}`);
+      }
+
+      const port = options.port || 3000;
+      const env = { ...process.env, PORT: port.toString() };
+
+      this._devServer = spawn('rushx', ['dev'], {
+        cwd: browserProjectPath,
+        env,
+        stdio: options.verbose ? 'inherit' : ['ignore', 'pipe', 'pipe']
+      });
+
+      this._devServer.on('error', (error) => {
+        return fail(`Failed to start development server: ${error}`);
+      });
+
+      // Give the server a moment to start
+      await this._sleep(3000);
+
+      if (this._devServer && !this._devServer.killed) {
+        if (options.verbose) {
+          console.log('Development server process started successfully');
+        }
+        return succeed(undefined);
+      } else {
+        return fail('Development server process failed to start');
+      }
+    } catch (error) {
+      return fail(`Failed to start development server: ${error}`);
+    }
+  }
+
+  /**
+   * Waits for the development server to be ready by checking HTTP availability
+   */
+  private async _waitForServerReady(
+    port: number,
+    verbose: boolean,
+    maxAttempts: number = 60
+  ): Promise<Result<void>> {
+    for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+      try {
+        const isReady = await this._checkServerHealth(port);
+        if (isReady) {
+          if (verbose) {
+            console.log(`Server is ready at http://localhost:${port}`);
+          }
+          return succeed(undefined);
+        }
+      } catch (error) {
+        // Server not ready yet, continue waiting
+      }
+
+      if (verbose && attempt % 10 === 0) {
+        console.log(`Waiting for server to be ready... (attempt ${attempt}/${maxAttempts})`);
+      }
+
+      await this._sleep(1000);
+    }
+
+    return fail(`Server did not become ready after ${maxAttempts} attempts`);
+  }
+
+  /**
+   * Checks if the server is responding
+   */
+  private async _checkServerHealth(port: number): Promise<boolean> {
+    return new Promise((resolve) => {
+      const request = http.get(`http://localhost:${port}`, (res) => {
+        resolve(res.statusCode !== undefined && res.statusCode >= 200 && res.statusCode < 400);
+      });
+
+      request.on('error', () => {
+        resolve(false);
+      });
+
+      request.setTimeout(3000, () => {
+        request.destroy();
+        resolve(false);
+      });
+    });
+  }
+
+  /**
+   * Stops the development server
+   */
+  private _stopDevServer(): void {
+    if (this._devServer && !this._devServer.killed) {
+      this._devServer.kill('SIGTERM');
+      setTimeout(() => {
+        if (this._devServer && !this._devServer.killed) {
+          this._devServer.kill('SIGKILL');
+        }
+      }, 5000);
+    }
+  }
+
+  /**
+   * Sleep for the specified number of milliseconds
+   */
+  private _sleep(ms: number): Promise<void> {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+
+  /**
+   * Determines if a ZIP archive should be created based on the options
+   */
+  private _shouldCreateZip(options: IBrowseOptions): boolean {
+    // Create ZIP if input or config are file paths (not predefined names)
+    const hasFilePath = (path: string | undefined): boolean => {
+      if (!path) return false;
+      // Check if it's a file path (contains directory separators or file extensions)
+      return path.includes('/') || path.includes('\\') || (path.includes('.') && !path.startsWith('.'));
+    };
+
+    return hasFilePath(options.input) || hasFilePath(options.config);
+  }
+
+  /**
+   * Creates a ZIP archive containing the input and config files
+   */
+  private async _createZipArchive(
+    options: IBrowseOptions
+  ): Promise<Result<{ zipPath: string; manifest: any }>> {
+    try {
+      return await zipArchiver.createArchive({
+        input: options.input,
+        config: options.config
+      });
+    } catch (error) {
+      return fail(`Failed to create ZIP archive: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+
+  /**
+   * Graceful shutdown - stops development server if running
+   */
+  public shutdown(): void {
+    this._stopDevServer();
+  }
+}