@fluojs/cli 1.0.0-beta.3 → 1.0.0-beta.5

package/dist/commands/scripts.js

@@ -0,0 +1,418 @@
+import { spawn } from 'node:child_process';
+import { existsSync, readFileSync } from 'node:fs';
+import { delimiter, dirname, join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { SUPPORTED_PACKAGE_MANAGERS } from './package-manager.js';
+const EMPTY_ENV = {};
+const FAILURE_STDOUT_BUFFER_LIMIT = 16_384;
+function getCliSourceRoot() {
+  return dirname(dirname(fileURLToPath(import.meta.url)));
+}
+function getCliEntryPoint() {
+  return join(getCliSourceRoot(), 'cli.js');
+}
+function isRecord(value) {
+  return typeof value === 'object' && value !== null;
+}
+function readJsonFile(filePath) {
+  try {
+    const parsed = JSON.parse(readFileSync(filePath, 'utf8'));
+    return isRecord(parsed) ? parsed : undefined;
+  } catch (_error) {
+    return undefined;
+  }
+}
+function findProjectManifest(startDirectory) {
+  let current = resolve(startDirectory);
+  while (true) {
+    const candidate = join(current, 'package.json');
+    if (existsSync(candidate)) {
+      const manifest = readJsonFile(candidate);
+      if (manifest) {
+        return {
+          directory: current,
+          manifest,
+          path: candidate
+        };
+      }
+    }
+    const parent = dirname(current);
+    if (parent === current) {
+      return undefined;
+    }
+    current = parent;
+  }
+}
+function hasManifestDependency(manifest, packageName) {
+  for (const field of ['dependencies', 'devDependencies', 'optionalDependencies']) {
+    const entries = manifest[field];
+    if (isRecord(entries) && typeof entries[packageName] === 'string') {
+      return true;
+    }
+  }
+  return false;
+}
+function detectProjectRuntime(manifest) {
+  if (hasManifestDependency(manifest, '@fluojs/platform-bun')) {
+    return 'bun';
+  }
+  if (hasManifestDependency(manifest, '@fluojs/platform-deno')) {
+    return 'deno';
+  }
+  if (hasManifestDependency(manifest, '@fluojs/platform-cloudflare-workers')) {
+    return 'cloudflare-workers';
+  }
+  return 'node';
+}
+function withDefaultNodeEnv(env, defaultNodeEnv) {
+  if (env.NODE_ENV) {
+    return {
+      ...env
+    };
+  }
+  return {
+    ...env,
+    NODE_ENV: defaultNodeEnv
+  };
+}
+function findPathEnvKey(env) {
+  return Object.keys(env).find(key => key.toLowerCase() === 'path') ?? 'PATH';
+}
+function withProjectLocalBin(env, projectDirectory) {
+  const pathKey = findPathEnvKey(env);
+  const existingPath = env[pathKey];
+  const localBin = join(projectDirectory, 'node_modules', '.bin');
+  return {
+    ...env,
+    [pathKey]: existingPath ? `${localBin}${delimiter}${existingPath}` : localBin
+  };
+}
+function defaultSpawnCommand(command, args, options) {
+  return new Promise((resolveExitCode, reject) => {
+    const child = spawn(command, args, options);
+    if (options.stdio === 'pipe') {
+      child.stdout?.on('data', chunk => options.stdout?.write(String(chunk)));
+      child.stderr?.on('data', chunk => options.stderr?.write(String(chunk)));
+    }
+    child.on('error', reject);
+    child.on('close', code => resolveExitCode(code ?? 1));
+  });
+}
+function buildNativeNodeWatchStep(passThrough) {
+  return {
+    command: 'node',
+    args: ['--env-file=.env', '--watch', '--watch-preserve-output', '--import', 'tsx', 'src/main.ts', ...passThrough],
+    mode: 'native-watch'
+  };
+}
+function buildProjectRunner(command, runtime, passThrough, options) {
+  if (command === 'build') {
+    switch (runtime) {
+      case 'bun':
+        return [{
+          command: 'bun',
+          args: ['build', './src/main.ts', '--outdir', './dist', '--target', 'bun', ...passThrough]
+        }];
+      case 'deno':
+        return [{
+          command: 'deno',
+          args: ['compile', '--allow-env', '--allow-net', '--output', join('dist', 'app'), 'src/main.ts', ...passThrough]
+        }];
+      case 'cloudflare-workers':
+        return [{
+          command: 'wrangler',
+          args: ['deploy', '--dry-run', ...passThrough]
+        }];
+      default:
+        return [{
+          command: 'vite',
+          args: ['build', ...passThrough],
+          mode: 'single-run'
+        }, {
+          command: 'tsc',
+          args: ['-p', 'tsconfig.build.json'],
+          mode: 'single-run'
+        }];
+    }
+  }
+  if (command === 'dev') {
+    switch (runtime) {
+      case 'bun':
+        return [{
+          command: 'bun',
+          args: ['--watch', 'src/main.ts', ...passThrough]
+        }];
+      case 'deno':
+        return [{
+          command: 'deno',
+          args: ['run', '--allow-env', '--allow-net', '--watch', 'src/main.ts', ...passThrough]
+        }];
+      case 'cloudflare-workers':
+        return [{
+          command: 'wrangler',
+          args: ['dev', ...passThrough],
+          mode: 'native-watch'
+        }];
+      default:
+        if (options.rawWatch) {
+          return [buildNativeNodeWatchStep(passThrough)];
+        }
+        return [{
+          command: 'node',
+          args: ['--import', 'tsx', getCliEntryPoint(), '__node-dev-runner', '--', ...passThrough],
+          mode: 'fluo-node-restart'
+        }];
+    }
+  }
+  switch (runtime) {
+    case 'bun':
+      return [{
+        command: 'bun',
+        args: ['dist/main.js', ...passThrough]
+      }];
+    case 'deno':
+      return [{
+        command: join('dist', 'app'),
+        args: [...passThrough]
+      }];
+    case 'cloudflare-workers':
+      return [{
+        command: 'wrangler',
+        args: ['dev', '--remote', ...passThrough]
+      }];
+    default:
+      return [{
+        command: 'node',
+        args: ['dist/main.js', ...passThrough],
+        mode: 'single-run'
+      }];
+  }
+}
+async function runProjectRunnerSteps(steps, runtime, options) {
+  for (const step of steps) {
+    const exitCode = await runtime.spawnCommand(step.command, step.args, options);
+    if (exitCode !== 0) {
+      return exitCode;
+    }
+  }
+  return 0;
+}
+function parseScriptArgs(argv) {
+  let dryRun = false;
+  let packageManager;
+  let rawWatch = false;
+  let reporter = 'auto';
+  let verbose = false;
+  const passThrough = [];
+  for (let index = 0; index < argv.length; index += 1) {
+    const arg = argv[index];
+    if (arg === '--dry-run') {
+      dryRun = true;
+      continue;
+    }
+    if (arg === '--verbose') {
+      verbose = true;
+      continue;
+    }
+    if (arg === '--raw-watch') {
+      rawWatch = true;
+      continue;
+    }
+    if (arg === '--reporter') {
+      const value = argv[index + 1];
+      if (!value || value.startsWith('-')) {
+        throw new Error('Expected --reporter to have a value.');
+      }
+      if (!(value === 'auto' || value === 'stream' || value === 'silent')) {
+        throw new Error(`Invalid --reporter value "${value}". Use one of: auto, stream, silent.`);
+      }
+      reporter = value;
+      index += 1;
+      continue;
+    }
+    if (arg === '--package-manager') {
+      const value = argv[index + 1];
+      if (!value || value.startsWith('-')) {
+        throw new Error('Expected --package-manager to have a value.');
+      }
+      if (!SUPPORTED_PACKAGE_MANAGERS.has(value)) {
+        throw new Error(`Invalid --package-manager value "${value}". Use one of: pnpm, npm, yarn, bun.`);
+      }
+      packageManager = value;
+      index += 1;
+      continue;
+    }
+    if (arg === '--') {
+      passThrough.push(...argv.slice(index + 1));
+      break;
+    }
+    passThrough.push(arg);
+  }
+  return {
+    dryRun,
+    packageManager,
+    passThrough,
+    rawWatch,
+    reporter,
+    verbose
+  };
+}
+function isEnabledEnvironmentFlag(value) {
+  return value === '1' || value === 'true' || value === 'yes' || value === 'on';
+}
+function resolveReporterMode(command, parsed, runtime) {
+  if (parsed.reporter !== 'auto') {
+    return parsed.reporter;
+  }
+  if (parsed.verbose || isEnabledEnvironmentFlag(runtime.env?.FLUO_VERBOSE)) {
+    return 'stream';
+  }
+  if (runtime.ci || isEnabledEnvironmentFlag(runtime.env?.CI) || isEnabledEnvironmentFlag(runtime.env?.GITHUB_ACTIONS)) {
+    return 'stream';
+  }
+  if (command !== 'dev') {
+    return 'stream';
+  }
+  return (runtime.stdout ?? process.stdout).isTTY ? 'pretty' : 'stream';
+}
+function renderStep(step) {
+  return `${step.command} ${step.args.join(' ')}`.trim();
+}
+function createBoundedBufferStream(limit) {
+  let buffer = '';
+  return {
+    flush(target) {
+      if (buffer.length > 0) {
+        target.write(buffer);
+      }
+    },
+    hasContent() {
+      return buffer.length > 0;
+    },
+    write(message) {
+      buffer += message;
+      if (buffer.length > limit) {
+        buffer = buffer.slice(buffer.length - limit);
+      }
+    }
+  };
+}
+function createReporterStreams(mode, verbose, stdout, stderr) {
+  if (mode === 'stream') {
+    return {
+      flushBufferedStdoutOnFailure() {},
+      stdio: 'inherit'
+    };
+  }
+  if (mode === 'silent' || mode === 'pretty') {
+    if (verbose) {
+      return {
+        flushBufferedStdoutOnFailure() {},
+        stderr,
+        stdio: 'pipe',
+        stdout
+      };
+    }
+    const bufferedStdout = createBoundedBufferStream(FAILURE_STDOUT_BUFFER_LIMIT);
+    return {
+      flushBufferedStdoutOnFailure() {
+        if (bufferedStdout.hasContent()) {
+          stderr.write('[fluo] child stdout before failure:\n');
+          bufferedStdout.flush(stderr);
+          stderr.write('\n');
+        }
+      },
+      stderr,
+      stdio: 'pipe',
+      stdout: bufferedStdout
+    };
+  }
+  return {
+    flushBufferedStdoutOnFailure() {},
+    stdio: 'inherit'
+  };
+}
+
+/**
+ * Renders lifecycle command help text.
+ *
+ * @param command Lifecycle command whose help text should be rendered.
+ * @returns Human-readable lifecycle command usage text.
+ */
+export function scriptUsage(command) {
+  const nodeEnv = command === 'dev' ? 'development' : 'production';
+  return [`Usage: fluo ${command} [options] [-- <args>]`, '', `Run the generated fluo project ${command} lifecycle with NODE_ENV defaulting to ${nodeEnv} when unset.`, '', 'Options', '  --dry-run                              Print the command without running it.', command === 'dev' ? '  --raw-watch                            Use the runtime-native watcher instead of the fluo Node restart runner.' : undefined, '  --reporter <auto|stream|silent>        Choose lifecycle reporter output mode (default: auto).', '  --verbose                             Expose raw child process output; also honored by FLUO_VERBOSE=1.', `  --help                                 Show help for the ${command} command.`].filter(line => typeof line === 'string').join('\n');
+}
+
+/**
+ * Runs one generated-project lifecycle command through the CLI-owned runtime command matrix.
+ *
+ * @param command Lifecycle command to run.
+ * @param argv Command-specific arguments after the lifecycle command name.
+ * @param runtime Runtime dependencies used by tests, sandboxes, and embedders.
+ * @returns Process-style exit code from the lifecycle command.
+ */
+export async function runScriptCommand(command, argv, runtime = {}) {
+  if (argv.includes('--help') || argv.includes('-h')) {
+    (runtime.stdout ?? process.stdout).write(`${scriptUsage(command)}\n`);
+    return 0;
+  }
+  const env = runtime.env ?? EMPTY_ENV;
+  const stdout = runtime.stdout ?? process.stdout;
+  const stderr = runtime.stderr ?? process.stderr;
+  const project = findProjectManifest(runtime.cwd ?? process.cwd());
+  if (!project) {
+    throw new Error(`Unable to find package.json for fluo ${command}.`);
+  }
+  const parsed = parseScriptArgs(argv);
+  const projectRuntime = detectProjectRuntime(project.manifest);
+  const defaultNodeEnv = command === 'dev' ? 'development' : 'production';
+  const childEnv = withProjectLocalBin(withDefaultNodeEnv(env, defaultNodeEnv), project.directory);
+  const rawWatch = parsed.rawWatch || isEnabledEnvironmentFlag(env.FLUO_DEV_RAW_WATCH);
+  const runnerSteps = buildProjectRunner(command, projectRuntime, parsed.passThrough, {
+    rawWatch
+  });
+  const reporterMode = resolveReporterMode(command, parsed, {
+    ...runtime,
+    env,
+    stdout
+  });
+  const verbose = parsed.verbose || isEnabledEnvironmentFlag(env.FLUO_VERBOSE);
+  if (parsed.dryRun) {
+    for (const step of runnerSteps) {
+      stdout.write(`Would run: ${step.command} ${step.args.join(' ')}\n`);
+    }
+    stdout.write(`Project: ${project.path}\n`);
+    stdout.write(`Runtime: ${projectRuntime}\n`);
+    stdout.write(`NODE_ENV: ${childEnv.NODE_ENV ?? ''}\n`);
+    stdout.write(`Reporter: ${reporterMode}\n`);
+    if (command === 'dev') {
+      stdout.write(`Watch mode: ${runnerSteps.map(step => step.mode ?? 'single-run').join(', ')}\n`);
+    }
+    return 0;
+  }
+  if (reporterMode === 'pretty') {
+    stdout.write(`[fluo] ${command} ${projectRuntime} lifecycle starting\n`);
+    stdout.write(`[fluo] ${runnerSteps.map(renderStep).join(' && ')}\n`);
+  }
+  const reporterStreams = createReporterStreams(reporterMode, verbose, stdout, stderr);
+  const exitCode = await runProjectRunnerSteps(runnerSteps, {
+    spawnCommand: runtime.spawnCommand ?? defaultSpawnCommand
+  }, {
+    cwd: project.directory,
+    env: childEnv,
+    ...reporterStreams
+  });
+  if (reporterMode === 'pretty') {
+    if (exitCode === 0) {
+      stdout.write(`[fluo] ${command} lifecycle completed\n`);
+    } else {
+      reporterStreams.flushBufferedStdoutOnFailure();
+      stderr.write(`[fluo] ${command} lifecycle failed with exit code ${exitCode}\n`);
+    }
+  } else if (reporterMode === 'silent' && exitCode !== 0) {
+    reporterStreams.flushBufferedStdoutOnFailure();
+    stderr.write(`[fluo] ${command} lifecycle failed with exit code ${exitCode}\n`);
+  }
+  return exitCode;
+}

package/dist/dev-runner/node-restart-runner.d.ts

@@ -0,0 +1,50 @@
+import { type ChildProcess } from 'node:child_process';
+import { type FSWatcher } from 'node:fs';
+type RestartRunnerStream = {
+    write(message: string): unknown;
+};
+type RestartChildSpawner = (command: string, args: string[], options: {
+    cwd: string;
+    env: NodeJS.ProcessEnv;
+    stdio: 'inherit';
+}) => ChildProcess;
+type RestartSignal = 'SIGINT' | 'SIGTERM';
+type RestartSignalTarget = {
+    off(signal: RestartSignal, listener: () => void): unknown;
+    once(signal: RestartSignal, listener: () => void): unknown;
+};
+type RestartWatcherFactory = (target: string, optionsOrListener: {
+    recursive: boolean;
+} | ((event: string, filename: string | Buffer | null) => void), listener?: (event: string, filename: string | Buffer | null) => void) => FSWatcher;
+type ContentChangeGate = {
+    commitBaseline(paths: Iterable<string>): void;
+    hasMeaningfulChange(paths: Iterable<string>): boolean;
+};
+export type NodeRestartRunnerOptions = {
+    appArgs?: string[];
+    debounceMs?: number;
+    env: NodeJS.ProcessEnv;
+    projectDirectory?: string;
+    signalTarget?: RestartSignalTarget;
+    spawnChild?: RestartChildSpawner;
+    stderr?: RestartRunnerStream;
+    stdout?: RestartRunnerStream;
+    watchTarget?: RestartWatcherFactory;
+};
+/**
+ * Creates a content-diff gate for fluo-owned dev restarts.
+ *
+ * @param projectDirectory Project root used for ignore matching.
+ * @param ignorePatterns Additional or default ignore patterns to apply before hashing.
+ * @returns A gate that reports whether watched paths changed by content rather than by filesystem event alone.
+ */
+export declare function createContentChangeGate(projectDirectory: string, ignorePatterns?: string[]): ContentChangeGate;
+/**
+ * Runs the Node.js development lifecycle through fluo-owned restart supervision.
+ *
+ * @param options Runner dependencies and project settings.
+ * @returns A promise that resolves with the final child exit code when the runner stops.
+ */
+export declare function runNodeRestartRunner(options: NodeRestartRunnerOptions): Promise<number>;
+export {};
+//# sourceMappingURL=node-restart-runner.d.ts.map

package/dist/dev-runner/node-restart-runner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"node-restart-runner.d.ts","sourceRoot":"","sources":["../../src/dev-runner/node-restart-runner.ts"],"names":[],"mappings":"AAAA,OAAO,EAAS,KAAK,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAE9D,OAAO,EAA0D,KAAK,SAAS,EAAE,MAAM,SAAS,CAAC;AAGjG,KAAK,mBAAmB,GAAG;IACzB,KAAK,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC;CACjC,CAAC;AAEF,KAAK,mBAAmB,GAAG,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,EAAE,OAAO,EAAE;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAC,UAAU,CAAC;IAAC,KAAK,EAAE,SAAS,CAAA;CAAE,KAAK,YAAY,CAAC;AAEjJ,KAAK,aAAa,GAAG,QAAQ,GAAG,SAAS,CAAC;AAE1C,KAAK,mBAAmB,GAAG;IACzB,GAAG,CAAC,MAAM,EAAE,aAAa,EAAE,QAAQ,EAAE,MAAM,IAAI,GAAG,OAAO,CAAC;IAC1D,IAAI,CAAC,MAAM,EAAE,aAAa,EAAE,QAAQ,EAAE,MAAM,IAAI,GAAG,OAAO,CAAC;CAC5D,CAAC;AAEF,KAAK,qBAAqB,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,iBAAiB,EAAE;IAAE,SAAS,EAAE,OAAO,CAAA;CAAE,GAAG,CAAC,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,KAAK,IAAI,CAAC,EAAE,QAAQ,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,KAAK,IAAI,KAAK,SAAS,CAAC;AAE1O,KAAK,iBAAiB,GAAG;IACvB,cAAc,CAAC,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,GAAG,IAAI,CAAC;IAC9C,mBAAmB,CAAC,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,GAAG,OAAO,CAAC;CACvD,CAAC;AAEF,MAAM,MAAM,wBAAwB,GAAG;IACrC,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;IACnB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,GAAG,EAAE,MAAM,CAAC,UAAU,CAAC;IACvB,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,YAAY,CAAC,EAAE,mBAAmB,CAAC;IACnC,UAAU,CAAC,EAAE,mBAAmB,CAAC;IACjC,MAAM,CAAC,EAAE,mBAAmB,CAAC;IAC7B,MAAM,CAAC,EAAE,mBAAmB,CAAC;IAC7B,WAAW,CAAC,EAAE,qBAAqB,CAAC;CACrC,CAAC;AA6FF;;;;;;GAMG;AACH,wBAAgB,uBAAuB,CAAC,gBAAgB,EAAE,MAAM,EAAE,cAAc,GAAE,MAAM,EAAoB,GAAG,iBAAiB,CAuB/H;AAYD;;;;;GAKG;AACH,wBAAsB,oBAAoB,CAAC,OAAO,EAAE,wBAAwB,GAAG,OAAO,CAAC,MAAM,CAAC,CAqJ7F"}