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

package/src/cli.ts

@@ -27,20 +27,19 @@ import { promises as fs } from 'fs';
 import * as path from 'path';
 
 import { IBrowseOptions, IBrowseCommandOptions } from './options';
-import { BrowserLauncher } from './browserLauncher';
+import { SimpleBrowserLauncher } from './simpleBrowserLauncher';
 
 /**
  * Main CLI class for ts-res-browser-cli
  */
 export class TsResBrowserCliApp {
   private readonly _program: Command;
-  private readonly _launcher: BrowserLauncher;
+  private readonly _launcher: SimpleBrowserLauncher;
 
   public constructor() {
     this._program = new Command();
-    this._launcher = new BrowserLauncher();
+    this._launcher = new SimpleBrowserLauncher();
     this._setupCommands();
-    this._setupGracefulShutdown();
   }
 
   /**
@@ -89,6 +88,11 @@ export class TsResBrowserCliApp {
       .option('--no-open', 'Do not open browser automatically')
       .option('--interactive', 'Launch in interactive mode with sample data', false)
       .option('--dev', 'Automatically start development server locally', false)
+      .option(
+        '--serve',
+        'Start server (dev in monorepo, serve in published packages) and connect automatically',
+        false
+      )
       .action(async (options) => {
         // If no options provided, show help
         if (!this._hasOptions(options)) {
@@ -130,6 +134,11 @@ export class TsResBrowserCliApp {
       .option('--no-open', 'Do not open browser automatically')
       .option('--interactive', 'Launch in interactive mode with sample data', false)
       .option('--dev', 'Automatically start development server locally', false)
+      .option(
+        '--serve',
+        'Start server (dev in monorepo, serve in published packages) and connect automatically',
+        false
+      )
       .action(async (options) => {
         await this._handleBrowseCommand(options);
       });
@@ -167,7 +176,8 @@ export class TsResBrowserCliApp {
       options.reduceQualifiers ||
       options.interactive ||
       options.url ||
-      options.dev
+      options.dev ||
+      options.serve
     );
   }
 
@@ -398,7 +408,8 @@ export class TsResBrowserCliApp {
         url: options.url,
         open: options.open,
         interactive: options.interactive || false,
-        dev: options.dev || false
+        dev: options.dev || false,
+        serve: options.serve || false
       };
 
       return succeed(browseOptions);
@@ -406,18 +417,4 @@ export class TsResBrowserCliApp {
       return fail(`Failed to parse options: ${error}`);
     }
   }
-
-  /**
-   * Sets up graceful shutdown handling
-   */
-  private _setupGracefulShutdown(): void {
-    const shutdown = (signal: string) => {
-      console.log(`\nReceived ${signal}, shutting down gracefully...`);
-      this._launcher.shutdown();
-      process.exit(0);
-    };
-
-    process.on('SIGINT', () => shutdown('SIGINT'));
-    process.on('SIGTERM', () => shutdown('SIGTERM'));
-  }
 }

package/src/index.ts

@@ -23,4 +23,4 @@
 // Export main components
 export * from './cli';
 export * from './options';
-export * from './browserLauncher';
+export * from './simpleBrowserLauncher';

package/src/options.ts

@@ -95,6 +95,11 @@ export interface IBrowseOptions {
    */
   dev?: boolean;
 
+  /**
+   * Whether to start server (dev in monorepo, serve in published packages) and connect automatically
+   */
+  serve?: boolean;
+
   /**
    * Whether to use ZIP loading mode (internal flag)
    */
@@ -130,4 +135,5 @@ export interface IBrowseCommandOptions {
   interactive?: boolean;
   url?: string;
   dev?: boolean;
+  serve?: boolean;
 }

package/src/{browserLauncher.ts → simpleBrowserLauncher.ts}

@@ -20,24 +20,33 @@
  * SOFTWARE.
  */
 
-import { exec, spawn, ChildProcess } from 'child_process';
+import { exec } 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
+ * Simplified browser launcher using direct dependency on ts-res-browser
  */
-export class BrowserLauncher {
-  private _devServer?: ChildProcess;
+export class SimpleBrowserLauncher {
   /**
    * Launches the browser with the specified options
    */
   public async launch(options: IBrowseOptions): Promise<Result<void>> {
     try {
+      // Validate options before proceeding
+      if (options.interactive && !options.dev && !options.serve && !options.url) {
+        return fail(
+          'Interactive mode requires either --dev/--serve to start a local server or --url to specify a remote server.\n\n' +
+            'Examples:\n' +
+            '  ts-res-browser-cli --interactive --dev\n' +
+            '  ts-res-browser-cli --interactive --serve\n' +
+            '  ts-res-browser-cli --interactive --url https://example.com/ts-res-browser'
+        );
+      }
+
       // Check if we need to create a ZIP archive for file-based inputs
       let zipCreated = false;
       let finalOptions = { ...options };
@@ -70,28 +79,16 @@ export class BrowserLauncher {
         zipCreated = true;
       }
 
-      // Start development server if requested
-      if (finalOptions.dev && !finalOptions.url) {
+      // Start server if requested
+      if ((finalOptions.dev || finalOptions.serve) && !finalOptions.url) {
         if (!finalOptions.quiet) {
-          console.log('Starting TS-RES Browser development server...');
+          console.log('Starting TS-RES Browser server...');
         }
 
-        const serverResult = await this._startDevServer(finalOptions);
+        const serverResult = await this._startServer(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
@@ -136,6 +133,41 @@ export class BrowserLauncher {
     }
   }
 
+  /**
+   * Starts the server using ts-res-browser CLI directly
+   */
+  private async _startServer(options: IBrowseOptions): Promise<Result<void>> {
+    try {
+      // Use ts-res-browser directly from node_modules
+      const browserPath = require.resolve('@fgv/ts-res-browser/cli.js');
+      const command = `node "${browserPath}" ${options.dev ? 'dev' : 'serve'}`;
+
+      if (options.verbose) {
+        console.log(`Running: ${command}`);
+      }
+
+      return new Promise((resolve) => {
+        const child = exec(command, (error) => {
+          if (error) {
+            resolve(fail(`Failed to start server: ${error.message}`));
+          } else {
+            resolve(succeed(undefined));
+          }
+        });
+
+        // Give server time to start, then assume success
+        setTimeout(() => {
+          if (options.verbose) {
+            console.log('Server startup initiated');
+          }
+          resolve(succeed(undefined));
+        }, 2000);
+      });
+    } catch (error) {
+      return fail(`Failed to start server: ${error}`);
+    }
+  }
+
   /**
    * Opens the browser to the specified URL
    */
@@ -161,8 +193,9 @@ export class BrowserLauncher {
    * 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}`;
+    // Use provided URL or default based on server type
+    const defaultPort = options.dev ? 3000 : 8080;
+    const baseUrl = options.url || `http://localhost:${options.port || defaultPort}`;
     const params = new URLSearchParams();
 
     if (options.input) {
@@ -213,120 +246,6 @@ export class BrowserLauncher {
     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
    */
@@ -356,11 +275,4 @@ export class BrowserLauncher {
       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();
-  }
 }

package/src/zipArchiver.ts

@@ -1,8 +1,8 @@
-import * as archiver from 'archiver';
 import * as fs from 'fs';
 import * as path from 'path';
 import * as os from 'os';
 import { Result, succeed, fail } from '@fgv/ts-utils';
+import { ZipArchive } from '@fgv/ts-res';
 
 export interface ZipArchiveOptions {
   input?: string;
@@ -12,21 +12,7 @@ export interface ZipArchiveOptions {
 
 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;
-  };
+  manifest: ZipArchive.IZipArchiveManifest;
 }
 
 export class ZipArchiver {
@@ -45,92 +31,21 @@ export class ZipArchiver {
         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: ZipManifest = {
-        timestamp: new Date().toISOString()
-      };
-
-      // Promise to handle async archiving
-      const archivePromise = new Promise<void>((resolve, reject) => {
-        output.on('close', () => {
-          resolve();
-        });
-
-        output.on('error', (err: Error) => {
-          reject(err);
-        });
-
-        archive.on('error', (err: Error) => {
-          reject(err);
-        });
+      // Create ZIP archive using the new zip-archive packlet
+      const creator = new ZipArchive.ZipArchiveCreator();
+      const createResult = await creator.createFromBuffer({
+        inputPath: options.input,
+        configPath: options.config
       });
 
-      // 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 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 fail(`Config file does not exist: ${configPath}`);
-        }
-
-        const stats = fs.statSync(configPath);
-        if (!stats.isFile()) {
-          return 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}`
-        };
+      if (createResult.isFailure()) {
+        return fail(createResult.message);
       }
 
-      // Add manifest
-      archive.append(JSON.stringify(manifest, null, 2), { name: 'manifest.json' });
+      const { zipBuffer, manifest } = createResult.value;
 
-      // Finalize the archive
-      await archive.finalize();
-      await archivePromise;
+      // Write the ZIP buffer to disk
+      fs.writeFileSync(zipPath, zipBuffer);
 
       return succeed({
         zipPath,

package/.rush/temp/45629f175c0b2c015132e9451c317583db1c0e2d.tar.log

@@ -1,32 +0,0 @@
-Start time: Tue Jul 22 2025 06:50:10 GMT+0000 (Coordinated Universal Time)
-Invoking "/usr/bin/tar -c -f /home/runner/work/fgv/fgv/common/temp/build-cache/45629f175c0b2c015132e9451c317583db1c0e2d-2e166ad7fa3e8197.temp -z --files-from=-"
-
-======= BEGIN PROCESS INPUT ======
-.rush/temp/operation/build/all.log
-.rush/temp/operation/build/log-chunks.jsonl
-.rush/temp/operation/build/state.json
-lib/browserLauncher.d.ts
-lib/browserLauncher.d.ts.map
-lib/browserLauncher.js
-lib/browserLauncher.js.map
-lib/cli.d.ts
-lib/cli.d.ts.map
-lib/cli.js
-lib/cli.js.map
-lib/index.d.ts
-lib/index.d.ts.map
-lib/index.js
-lib/index.js.map
-lib/options.d.ts
-lib/options.d.ts.map
-lib/options.js
-lib/options.js.map
-lib/zipArchiver.d.ts
-lib/zipArchiver.d.ts.map
-lib/zipArchiver.js
-lib/zipArchiver.js.map
-======== END PROCESS INPUT =======
-======= BEGIN PROCESS OUTPUT =======
-======== END PROCESS OUTPUT ========
-
-Exited with code "0"

package/.rush/temp/chunked-rush-logs/ts-res-browser-cli.build.chunks.jsonl

@@ -1,5 +0,0 @@
-{"kind":"O","text":"Invoking: heft build --clean \n"}
-{"kind":"O","text":" ---- build started ---- \n"}
-{"kind":"O","text":"[build:typescript] Using TypeScript version 5.8.3\n"}
-{"kind":"O","text":" ---- build finished (4.946s) ---- \n"}
-{"kind":"O","text":"-------------------- Finished (4.952s) --------------------\n"}

package/.rush/temp/operation/build/all.log

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

package/.rush/temp/operation/build/log-chunks.jsonl

@@ -1,5 +0,0 @@
-{"kind":"O","text":"Invoking: heft build --clean \n"}
-{"kind":"O","text":" ---- build started ---- \n"}
-{"kind":"O","text":"[build:typescript] Using TypeScript version 5.8.3\n"}
-{"kind":"O","text":" ---- build finished (4.946s) ---- \n"}
-{"kind":"O","text":"-------------------- Finished (4.952s) --------------------\n"}

package/.rush/temp/operation/build/state.json

@@ -1,3 +0,0 @@
-{
-  "nonCachedDurationMs": 5542.026874999996
-}