crewx 0.8.1 → 0.8.2-rc.2

package/bin/crewx-lib.js

@@ -1,108 +1,213 @@
-/**
- * crewx launcher library — testable pure-logic functions extracted from crewx.js.
- */
-
-/**
- * Parse --port option from extra CLI args and validate the value.
- *
- * @param {string[]} extraArgs - remaining args after route resolution (e.g. ['--port', '3000'])
- * @returns {{ port: number } | { error: string } | null}
- *   - `{ port }` when a valid port is found
- *   - `{ error }` when --port is present but the value is invalid
- *   - `null` when --port is not specified
- */
-export function parseWebPort(extraArgs) {
-  const portIdx = extraArgs.indexOf('--port');
-  if (portIdx === -1) return null;
-  const portVal = Number(extraArgs[portIdx + 1]);
-  if (!portVal || portVal < 1 || portVal > 65535) {
-    return { error: 'Invalid port number. Use 1-65535.' };
-  }
-  return { port: portVal };
-}
-
-/**
- * Determine the route based on CLI arguments.
- * UI flags (--web, --no-open, --overlay, --electron, --desktop) are checked first.
- * Any other argument routes to CLI. No arguments → web default (with browser auto-open).
- *
- * @param {string[]} args - process.argv.slice(2)
- * @returns {{ route: string, routeArgs: string[] }}
- */
-export function resolveRoute(args) {
-  const firstArg = args[0];
-
-  if (firstArg === '--web') return { route: 'web', routeArgs: args.slice(1) };
-  if (firstArg === '--no-open') return { route: 'web', routeArgs: args.slice(1) };
-  if (firstArg === '--overlay') return { route: 'overlay', routeArgs: args.slice(1) };
-  if (firstArg === '--electron') return { route: 'electron-explicit', routeArgs: args.slice(1) };
-  if (firstArg === '--desktop') return { route: 'electron-explicit', routeArgs: args.slice(1) };
-  if (firstArg !== undefined) return { route: 'cli', routeArgs: args };
-  return { route: 'web-default', routeArgs: args };
-}
-
-/**
- * Forward signals to a child process for clean shutdown.
- *
- * Uses an `exited` flag (set by the child's 'exit' event) instead of
- * `child.killed`, because `child.killed` becomes `true` immediately after
- * calling `child.kill()` — even if the child process is still running.
- * This ensures the SIGKILL escalation timer can actually fire.
- *
- * On Windows, SIGTERM is equivalent to an immediate kill.
- *
- * @param {import('child_process').ChildProcess} child
- * @param {{ escalateKill?: boolean, detached?: boolean }} options
- */
-export function setupSignalForwarding(child, { escalateKill = false, detached = false } = {}) {
-  let exited = false;
-  let escalationScheduled = false;
-
-  child.on('exit', () => {
-    exited = true;
-  });
-
-  // When detached, the child runs in its own process group.
-  // Use process.kill(-pid) to kill the entire group (Electron + GPU helpers).
-  // When not detached, use child.kill() for single-process kill.
-  const killChild = (signal) => {
-    try {
-      if (detached) {
-        process.kill(-child.pid, signal);
-      } else {
-        child.kill(signal);
-      }
-    } catch {
-      // Process or process group already terminated
-    }
-  };
-
-  process.on('SIGINT', () => {
-    if (!exited) {
-      killChild('SIGTERM');
-      if (escalateKill && !escalationScheduled) {
-        escalationScheduled = true;
-        setTimeout(() => {
-          if (!exited) killChild('SIGKILL');
-        }, 3000).unref();
-      }
-    }
-  });
-
-  process.on('SIGTERM', () => {
-    if (!exited) killChild('SIGTERM');
-  });
-
-  process.on('SIGHUP', () => {
-    if (!exited) killChild('SIGHUP');
-  });
-
-  // Clean up the child process group when the parent exits unexpectedly
-  if (detached) {
-    process.on('exit', () => {
-      if (!exited) {
-        try { process.kill(-child.pid, 'SIGKILL'); } catch {}
-      }
-    });
-  }
-}
+/**
+ * crewx launcher library — testable pure-logic functions extracted from crewx.js.
+ */
+import { CLI_SUBCOMMANDS } from './cli-commands.js';
+import { buildHintMessage } from './launcher-flags.js';
+
+/**
+ * Parse serve-related flags: --port, --token, --token-file, --no-open.
+ * Strict mode: unknown --xxx tokens → { error } instead of silent absorption.
+ *
+ * @param {string[]} args
+ * @returns {{ port?: number, token?: string, tokenFile?: string, noOpen: boolean } | { error: string }}
+ */
+export function parseServeFlags(args) {
+  let port = undefined;
+  let token = undefined;
+  let tokenFile = undefined;
+  let noOpen = false;
+
+  const consumed = new Set();
+
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+
+    if (arg === '--port') {
+      const val = Number(args[i + 1]);
+      if (!val || val < 1 || val > 65535) {
+        return { error: 'Invalid port number. Use 1-65535.' };
+      }
+      port = val;
+      consumed.add(i);
+      consumed.add(i + 1);
+      i++;
+    } else if (arg?.startsWith('--port=')) {
+      const val = Number(arg.slice('--port='.length));
+      if (!val || val < 1 || val > 65535) {
+        return { error: 'Invalid port number. Use 1-65535.' };
+      }
+      port = val;
+      consumed.add(i);
+    } else if (arg === '--token') {
+      token = args[i + 1];
+      consumed.add(i);
+      consumed.add(i + 1);
+      i++;
+    } else if (arg?.startsWith('--token=')) {
+      token = arg.slice('--token='.length);
+      consumed.add(i);
+    } else if (arg === '--token-file') {
+      tokenFile = args[i + 1];
+      consumed.add(i);
+      consumed.add(i + 1);
+      i++;
+    } else if (arg?.startsWith('--token-file=')) {
+      tokenFile = arg.slice('--token-file='.length);
+      consumed.add(i);
+    } else if (arg === '--no-open') {
+      noOpen = true;
+      consumed.add(i);
+    } else if (arg === '--help' || arg === '-h') {
+      return { help: true };
+    }
+  }
+
+  // Strict: reject unconsumed --xxx flags
+  for (let i = 0; i < args.length; i++) {
+    if (consumed.has(i)) continue;
+    const arg = args[i];
+    if (arg?.startsWith('--')) {
+      return { error: `Unknown option for "crewx serve": ${arg}` };
+    }
+  }
+
+  return { port, token, tokenFile, noOpen };
+}
+
+/**
+ * Parse --port option from extra CLI args.
+ * Backward-compatible thin wrapper; kept for existing callers.
+ *
+ * @param {string[]} extraArgs
+ * @returns {{ port: number } | { error: string } | null}
+ */
+export function parseWebPort(extraArgs) {
+  const portIdx = extraArgs.indexOf('--port');
+  if (portIdx === -1) return null;
+  const portVal = Number(extraArgs[portIdx + 1]);
+  if (!portVal || portVal < 1 || portVal > 65535) {
+    return { error: 'Invalid port number. Use 1-65535.' };
+  }
+  return { port: portVal };
+}
+
+/**
+ * Determine the route based on CLI arguments.
+ *
+ * Priority order:
+ *   1. --help/-h, --version/-v → CLI (global options handled by CLI engine)
+ *   2. Known CLI subcommand    → CLI
+ *   3. 'serve' verb            → serve
+ *   4. 'electron' verb         → electron
+ *   5. No arguments            → web-default (browser auto-open)
+ *   6. Unknown first argument  → error with hint
+ *
+ * @param {string[]} args - process.argv.slice(2)
+ * @returns {{ route: string, routeArgs: string[], error?: string }}
+ */
+export function resolveRoute(args) {
+  const firstArg = args[0];
+
+  // 1. Global options → CLI engine handles them
+  if (firstArg === '--help' || firstArg === '-h') {
+    return { route: 'cli', routeArgs: args };
+  }
+  if (firstArg === '--version' || firstArg === '-v') {
+    return { route: 'cli', routeArgs: args };
+  }
+
+  // 2. CLI subcommand whitelist → CLI engine
+  if (firstArg !== undefined && CLI_SUBCOMMANDS.has(firstArg)) {
+    return { route: 'cli', routeArgs: args };
+  }
+
+  // 3. New verb: serve
+  if (firstArg === 'serve') {
+    return { route: 'serve', routeArgs: args.slice(1) };
+  }
+
+  // 4. New verb: electron
+  if (firstArg === 'electron') {
+    return { route: 'electron', routeArgs: args.slice(1) };
+  }
+
+  // 5. No arguments → web default
+  if (firstArg === undefined) {
+    return { route: 'web-default', routeArgs: [] };
+  }
+
+  // 6. Unknown → error with hint
+  const hint = buildHintMessage(firstArg);
+  const hintSuffix = hint ? `\n   ${hint}` : '\n   Run `crewx --help` for usage.';
+  return {
+    route: 'error',
+    error: `Unknown command or option: "${firstArg}"${hintSuffix}`,
+    routeArgs: args,
+  };
+}
+
+/**
+ * Forward signals to a child process for clean shutdown.
+ *
+ * Uses an `exited` flag (set by the child's 'exit' event) instead of
+ * `child.killed`, because `child.killed` becomes `true` immediately after
+ * calling `child.kill()` — even if the child process is still running.
+ * This ensures the SIGKILL escalation timer can actually fire.
+ *
+ * On Windows, SIGTERM is equivalent to an immediate kill.
+ *
+ * @param {import('child_process').ChildProcess} child
+ * @param {{ escalateKill?: boolean, detached?: boolean }} options
+ */
+export function setupSignalForwarding(child, { escalateKill = false, detached = false } = {}) {
+  let exited = false;
+  let escalationScheduled = false;
+
+  child.on('exit', () => {
+    exited = true;
+  });
+
+  // When detached, the child runs in its own process group.
+  // Use process.kill(-pid) to kill the entire group (Electron + GPU helpers).
+  // When not detached, use child.kill() for single-process kill.
+  const killChild = (signal) => {
+    try {
+      if (detached) {
+        process.kill(-child.pid, signal);
+      } else {
+        child.kill(signal);
+      }
+    } catch {
+      // Process or process group already terminated
+    }
+  };
+
+  process.on('SIGINT', () => {
+    if (!exited) {
+      killChild('SIGTERM');
+      if (escalateKill && !escalationScheduled) {
+        escalationScheduled = true;
+        setTimeout(() => {
+          if (!exited) killChild('SIGKILL');
+        }, 3000).unref();
+      }
+    }
+  });
+
+  process.on('SIGTERM', () => {
+    if (!exited) killChild('SIGTERM');
+  });
+
+  process.on('SIGHUP', () => {
+    if (!exited) killChild('SIGHUP');
+  });
+
+  // Clean up the child process group when the parent exits unexpectedly
+  if (detached) {
+    process.on('exit', () => {
+      if (!exited) {
+        try { process.kill(-child.pid, 'SIGKILL'); } catch {}
+      }
+    });
+  }
+}

package/bin/crewx-ui.js

@@ -1,83 +1,83 @@
-#!/usr/bin/env node
-/**
- * crewx-ui launcher
- *
- * Usage:
- *   npx crewx-ui              → NestJS web server (default)
- *   npx crewx-ui --electron   → Electron dashboard (main window)
- *   npx crewx-ui --overlay    → Electron floating overlay
- */
-import { spawn } from 'child_process';
-import { fileURLToPath } from 'url';
-import { dirname, join } from 'path';
-import { createRequire } from 'module';
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-
-const args = process.argv.slice(2);
-const isElectron = args.includes('--electron');
-const isOverlay = args.includes('--overlay');
-
-function getElectronSpawnEnv() {
-  const env = { ...process.env };
-  delete env.ELECTRON_RUN_AS_NODE;
-  env.NODE_ENV = 'production'; // Force production — prevents users from bypassing FREE limits via env
-  return env;
-}
-
-if (isElectron || isOverlay) {
-  // Electron mode: resolve binary path via require('electron')
-  const require = createRequire(import.meta.url);
-
-  let electronPath;
-  try {
-    electronPath = require('electron');
-  } catch {
-    console.error('');
-    console.error('  ❌ Electron is not installed.');
-    console.error('');
-    console.error('  To use --electron or --overlay mode, install Electron:');
-    console.error('');
-    console.error('    npm install -g electron');
-    console.error('    # or, in this project:');
-    console.error('    npm install --save-dev electron');
-    console.error('');
-    process.exit(1);
-  }
-
-  const entryFile = isOverlay
-    ? join(__dirname, '..', 'dist-electron', 'overlay.js')
-    : join(__dirname, '..', 'dist-electron', 'main.js');
-
-  if (process.env.ELECTRON_RUN_AS_NODE) {
-    console.warn(
-      '[crewx-ui] Ignoring ELECTRON_RUN_AS_NODE for Electron UI launch (it forces Electron into Node mode).',
-    );
-  }
-
-  const child = spawn(String(electronPath), [entryFile], {
-    stdio: 'inherit',
-    env: getElectronSpawnEnv(),
-  });
-
-  child.on('exit', (code) => process.exit(code ?? 0));
-  child.on('error', (err) => {
-    console.error('Failed to launch Electron:', err);
-    process.exit(1);
-  });
-} else {
-  // Default: delegate to server.js (NestJS web server)
-  const serverScript = join(__dirname, '..', 'server.js');
-
-  const child = spawn(process.execPath, [serverScript, ...args], {
-    stdio: 'inherit',
-    env: { ...process.env, NODE_ENV: 'production' }, // Force production — prevents users from bypassing FREE limits via env
-  });
-
-  child.on('exit', (code) => process.exit(code ?? 0));
-  child.on('error', (err) => {
-    console.error('Failed to start server:', err);
-    process.exit(1);
-  });
-}
+#!/usr/bin/env node
+/**
+ * crewx-ui launcher
+ *
+ * Usage:
+ *   npx crewx-ui              → NestJS web server (default)
+ *   npx crewx-ui --electron   → Electron dashboard (main window)
+ *   npx crewx-ui --overlay    → Electron floating overlay
+ */
+import { spawn } from 'child_process';
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+import { createRequire } from 'module';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+const args = process.argv.slice(2);
+const isElectron = args.includes('--electron');
+const isOverlay = args.includes('--overlay');
+
+function getElectronSpawnEnv() {
+  const env = { ...process.env };
+  delete env.ELECTRON_RUN_AS_NODE;
+  env.NODE_ENV = 'production'; // Force production — prevents users from bypassing FREE limits via env
+  return env;
+}
+
+if (isElectron || isOverlay) {
+  // Electron mode: resolve binary path via require('electron')
+  const require = createRequire(import.meta.url);
+
+  let electronPath;
+  try {
+    electronPath = require('electron');
+  } catch {
+    console.error('');
+    console.error('  ❌ Electron is not installed.');
+    console.error('');
+    console.error('  To use --electron or --overlay mode, install Electron:');
+    console.error('');
+    console.error('    npm install -g electron');
+    console.error('    # or, in this project:');
+    console.error('    npm install --save-dev electron');
+    console.error('');
+    process.exit(1);
+  }
+
+  const entryFile = isOverlay
+    ? join(__dirname, '..', 'dist-electron', 'overlay.js')
+    : join(__dirname, '..', 'dist-electron', 'main.js');
+
+  if (process.env.ELECTRON_RUN_AS_NODE) {
+    console.warn(
+      '[crewx-ui] Ignoring ELECTRON_RUN_AS_NODE for Electron UI launch (it forces Electron into Node mode).',
+    );
+  }
+
+  const child = spawn(String(electronPath), [entryFile], {
+    stdio: 'inherit',
+    env: getElectronSpawnEnv(),
+  });
+
+  child.on('exit', (code) => process.exit(code ?? 0));
+  child.on('error', (err) => {
+    console.error('Failed to launch Electron:', err);
+    process.exit(1);
+  });
+} else {
+  // Default: delegate to server.js (NestJS web server)
+  const serverScript = join(__dirname, '..', 'server.js');
+
+  const child = spawn(process.execPath, [serverScript, ...args], {
+    stdio: 'inherit',
+    env: { ...process.env, NODE_ENV: 'production' }, // Force production — prevents users from bypassing FREE limits via env
+  });
+
+  child.on('exit', (code) => process.exit(code ?? 0));
+  child.on('error', (err) => {
+    console.error('Failed to start server:', err);
+    process.exit(1);
+  });
+}