@bachbntdev/devcmd 0.0.0-stage → 2.7.1

package/src/runner/process.js

@@ -0,0 +1,80 @@
+// Copyright (c) 2026 bachbnt
+
+const { spawn } = require('child_process');
+
+const SIGNAL_EXIT_CODES = {
+  SIGINT: 130,
+  SIGTERM: 143,
+};
+
+function runProcess(command, options = {}) {
+  const spawnImpl = options.spawnImpl || spawn;
+  const signalSource = options.signalSource || process;
+  const stdio = options.stdio || 'inherit';
+
+  return new Promise((resolve) => {
+    let settled = false;
+    let forwardedSignal;
+    let child;
+
+    const finish = (result) => {
+      if (settled) return;
+      settled = true;
+      signalSource.removeListener('SIGINT', onSigint);
+      signalSource.removeListener('SIGTERM', onSigterm);
+      resolve(result);
+    };
+
+    const forwardSignal = (signal) => {
+      forwardedSignal = signal;
+      if (child && !child.killed) child.kill(signal);
+    };
+    const onSigint = () => forwardSignal('SIGINT');
+    const onSigterm = () => forwardSignal('SIGTERM');
+
+    try {
+      const spawnOptions = {
+        shell: false,
+        stdio,
+      };
+      if (command.cwd) spawnOptions.cwd = command.cwd;
+      child = spawnImpl(command.executable, command.args, spawnOptions);
+    } catch (error) {
+      finish({ ok: false, exitCode: error.code === 'ENOENT' ? 127 : 1, error });
+      return;
+    }
+
+    signalSource.once('SIGINT', onSigint);
+    signalSource.once('SIGTERM', onSigterm);
+
+    child.once('error', (error) => {
+      finish({ ok: false, exitCode: error.code === 'ENOENT' ? 127 : 1, error });
+    });
+    child.once('exit', (code, signal) => {
+      const finalSignal = signal || forwardedSignal;
+      if (finalSignal) {
+        finish({
+          ok: false,
+          exitCode: SIGNAL_EXIT_CODES[finalSignal] || 1,
+          signal: finalSignal,
+        });
+        return;
+      }
+      finish({ ok: code === 0, exitCode: code ?? 1 });
+    });
+  });
+}
+
+async function runSequence(commands, options = {}) {
+  for (let index = 0; index < commands.length; index += 1) {
+    const result = await runProcess(commands[index], options);
+    if (!result.ok) return { ...result, failedCommand: commands[index], failedIndex: index };
+  }
+  return { ok: true, exitCode: 0 };
+}
+
+module.exports = {
+  SIGNAL_EXIT_CODES,
+  runProcess,
+  runSequence,
+};

package/src/runtime/execute.js

@@ -0,0 +1,99 @@
+// Copyright (c) 2026 bachbnt
+
+const { spawn } = require('child_process');
+const { createHistoryEntry, saveHistory } = require('../commands/history');
+const { recordProject } = require('../projects/recent');
+const { assertExecutables } = require('../runner/check');
+const { formatSequence } = require('../runner/command');
+const { runSequence } = require('../runner/process');
+
+function buildNotificationCommand(message, platform = process.platform) {
+  if (platform === 'darwin') {
+    return {
+      executable: 'osascript',
+      args: [
+        '-e',
+        'on run argv',
+        '-e',
+        'display notification (item 1 of argv) with title "DevCmd"',
+        '-e',
+        'end run',
+        message,
+      ],
+    };
+  }
+  if (platform === 'linux') {
+    return { executable: 'notify-send', args: ['DevCmd', message] };
+  }
+  return undefined;
+}
+
+function sendNotification(message) {
+  try {
+    const command = buildNotificationCommand(message);
+    if (command) spawn(command.executable, command.args, { stdio: 'ignore' });
+  } catch {}
+}
+
+function describeFailure(result) {
+  if (result.signal === 'SIGINT') return 'Command cancelled by user.';
+  if (result.signal) return `Command stopped by ${result.signal}.`;
+  if (result.error?.code === 'ENOENT') {
+    return `Executable "${result.failedCommand.executable}" was not found in PATH.`;
+  }
+  if (result.error) return `Unable to start command: ${result.error.message}`;
+  return `Command exited with code ${result.exitCode}.`;
+}
+
+async function executeCommands(p, pc, commands, metadata, options = {}) {
+  const commandLine = formatSequence(commands);
+  p.log.step(`${options.dryRun ? 'Dry run' : 'Executing'}: ${pc.yellow(commandLine)}`);
+
+  if (options.dryRun) {
+    p.outro('No command was executed.');
+    return 0;
+  }
+
+  try {
+    if (options.requirements) assertExecutables(options.requirements);
+  } catch (error) {
+    p.outro(`${pc.red('✖')} ${error.message}`);
+    return 127;
+  }
+
+  const startTime = Date.now();
+  const result = await runSequence(commands);
+  const elapsed = Date.now() - startTime;
+  const notifyThreshold = (options.config ?? metadata.config)?.notify;
+  if (notifyThreshold > 0 && elapsed >= notifyThreshold * 1000) {
+    const status = result.ok ? '✔' : '✖';
+    const project = metadata.projectName ? ` — ${metadata.projectName}` : '';
+    sendNotification(`dev ${metadata.command}${project} ${status}`);
+  }
+
+  if (!result.ok) {
+    p.outro(`${pc.red('✖')} ${describeFailure(result)}`);
+    return result.exitCode;
+  }
+
+  try {
+    saveHistory(createHistoryEntry(metadata, commands));
+  } catch (error) {
+    p.log.warn(`Command succeeded, but history could not be saved: ${error.message}`);
+  }
+  if (metadata.projectPath) {
+    recordProject({
+      name: metadata.projectName,
+      type: metadata.projectType || metadata.command,
+      path: metadata.projectPath,
+    });
+  }
+  p.outro(`${pc.green('✔')} Command completed successfully.`);
+  return 0;
+}
+
+module.exports = {
+  buildNotificationCommand,
+  describeFailure,
+  executeCommands,
+};

package/src/utils/args.js

@@ -0,0 +1,219 @@
+// Copyright (c) 2026 bachbnt
+
+const { PACKAGE_MANAGERS, frameworkDefinitions } = require('../config');
+const { FILTER_COMMANDS, JSON_COMMANDS } = require('../constants');
+
+const FILTER_PATTERN = /^[@A-Za-z0-9._][@A-Za-z0-9._/-]*$/;
+
+function parseArgs(argv) {
+  const args = [...argv];
+  const command = args.shift();
+  const options = {
+    dryRun: false,
+    coldBoot: false,
+    shutdownAll: false,
+    clear: false,
+    project: undefined,
+    target: undefined,
+    typescript: undefined,
+    packageManager: undefined,
+    git: undefined,
+    eslint: undefined,
+    noInstall: false,
+    python: undefined,
+    editor: undefined,
+    opener: undefined,
+    list: false,
+    json: false,
+    fix: false,
+    yes: false,
+    filter: undefined,
+    search: undefined,
+    values: {},
+  };
+  const positionals = [];
+
+  while (args.length > 0) {
+    const arg = args.shift();
+
+    if (!arg.startsWith('-')) {
+      positionals.push(arg);
+      if (!options.target) options.target = arg;
+      continue;
+    }
+
+    if (arg === '--dry-run') options.dryRun = true;
+    else if (arg === '--cold-boot') options.coldBoot = true;
+    else if (arg === '--shutdown-all') options.shutdownAll = true;
+    else if (arg === '--clear') options.clear = true;
+    else if (arg === '--project') {
+      options.project = args.shift();
+      if (!options.project || options.project.startsWith('-')) {
+        throw new Error('--project requires a path.');
+      }
+    }
+    else if (arg === '--list') options.list = true;
+    else if (arg === '--json') options.json = true;
+    else if (arg === '--fix') options.fix = true;
+    else if (arg === '--yes' || arg === '-y') options.yes = true;
+    else if (arg === '--filter') {
+      options.filter = args.shift();
+      if (!options.filter || !FILTER_PATTERN.test(options.filter) || options.filter.includes('..')) {
+        throw new Error('--filter requires a workspace package name or directory.');
+      }
+    } else if (arg === '--search') {
+      options.search = args.shift();
+      if (!options.search || options.search.startsWith('-')) {
+        throw new Error('--search requires text.');
+      }
+    }
+    else if (arg === '--typescript' || arg === '--ts') options.typescript = true;
+    else if (arg === '--javascript' || arg === '--js') options.typescript = false;
+    else if (arg === '--git') options.git = true;
+    else if (arg === '--no-git') options.git = false;
+    else if (arg === '--eslint') options.eslint = true;
+    else if (arg === '--no-eslint') options.eslint = false;
+    else if (arg === '--no-install') options.noInstall = true;
+    else if (arg === '--install') options.noInstall = false;
+    else if (arg === '--python') {
+      options.python = args.shift();
+      if (!options.python || options.python.startsWith('-')) {
+        throw new Error('--python requires an executable name or path.');
+      }
+    } else if (arg === '--editor') {
+      options.editor = args.shift();
+      if (!options.editor || options.editor.startsWith('-')) {
+        throw new Error('--editor requires an application or executable name.');
+      }
+    } else if (arg === '--with') {
+      options.opener = args.shift();
+      if (!options.opener || options.opener.startsWith('-')) {
+        throw new Error('--with requires an opener name.');
+      }
+    } else if (arg === '--set') {
+      const assignment = args.shift();
+      const separator = assignment?.indexOf('=') ?? -1;
+      if (separator < 1) throw new Error('--set requires name=value.');
+      const name = assignment.slice(0, separator);
+      const value = assignment.slice(separator + 1);
+      if (!/^[A-Za-z][A-Za-z0-9_]*$/.test(name) || !value) {
+        throw new Error('--set requires a valid name and non-empty value.');
+      }
+      options.values[name] = value;
+    }
+    else if (PACKAGE_MANAGERS.includes(arg.replace(/^--/, ''))) {
+      options.packageManager = arg.replace(/^--/, '');
+    } else if (arg === '--package-manager' || arg === '--pm') {
+      options.packageManager = args.shift();
+      if (!PACKAGE_MANAGERS.includes(options.packageManager)) {
+        throw new Error(`Package manager must be one of: ${PACKAGE_MANAGERS.join(', ')}`);
+      }
+    } else {
+      throw new Error(`Unsupported option: ${arg}`);
+    }
+  }
+
+  return { command, options, positionals };
+}
+
+function validateCommandFlags(command, options, definitions = frameworkDefinitions) {
+  if (options.coldBoot && command !== 'android') {
+    throw new Error('--cold-boot is only supported by the android command.');
+  }
+  if (options.clear && command !== 'history') {
+    throw new Error('--clear is only supported by the history command.');
+  }
+  if (options.project && command !== 'history') {
+    throw new Error('--project is only supported by the history command.');
+  }
+  if (options.shutdownAll && command !== 'ios') {
+    throw new Error('--shutdown-all is only supported by the ios command.');
+  }
+  if (options.list && command !== 'open') {
+    throw new Error('--list is only supported by the open command.');
+  }
+  if (options.opener && command !== 'open') {
+    throw new Error('--with is only supported by the open command.');
+  }
+  if (options.editor && command !== 'open') {
+    throw new Error('--editor is only supported by the open command.');
+  }
+  if (options.json && !JSON_COMMANDS.includes(command)) {
+    throw new Error(`--json is only supported by: ${JSON_COMMANDS.join(', ')}.`);
+  }
+  if (options.fix && command !== 'lint') {
+    throw new Error('--fix is only supported by the lint command.');
+  }
+  if (options.yes && command !== 'trust') {
+    throw new Error('--yes is only supported by the trust command.');
+  }
+  if (options.filter && !FILTER_COMMANDS.includes(command)) {
+    throw new Error(`--filter is only supported by: ${FILTER_COMMANDS.join(', ')}.`);
+  }
+  if (options.search && command !== 'history') {
+    throw new Error('--search is only supported by the history command.');
+  }
+  if (options.editor && options.opener) {
+    throw new Error('--editor and --with cannot be used together.');
+  }
+
+  const hasPreset =
+    options.typescript !== undefined ||
+    options.packageManager !== undefined ||
+    options.git !== undefined ||
+    options.eslint !== undefined ||
+    options.noInstall ||
+    options.python !== undefined ||
+    Object.keys(options.values || {}).length > 0;
+  if (hasPreset && !definitions[command]) {
+    throw new Error('Project preset options can only be used with framework commands.');
+  }
+}
+
+function validateFrameworkOptions(command, options, definitions = frameworkDefinitions) {
+  const definition = definitions[command];
+  if (!definition) throw new Error(`Unsupported framework: ${command}`);
+
+  const capabilities = definition.capabilities;
+  if (options.typescript !== undefined && !capabilities.language) {
+    throw new Error(`${command} does not support selecting TypeScript or JavaScript.`);
+  }
+  if (options.packageManager && !capabilities.packageManager) {
+    throw new Error(`${command} does not support selecting a package manager.`);
+  }
+  if (options.git !== undefined && !capabilities.git) {
+    throw new Error(`${command} does not support configuring Git initialization.`);
+  }
+  if (options.eslint !== undefined && !capabilities.eslint) {
+    throw new Error(`${command} does not support configuring ESLint.`);
+  }
+  if (options.noInstall && !capabilities.noInstall) {
+    throw new Error(`${command} does not support --no-install.`);
+  }
+  if (options.python && !capabilities.python) {
+    throw new Error(`${command} does not support selecting a Python executable.`);
+  }
+  if (
+    Array.isArray(capabilities.packageManager) &&
+    options.packageManager &&
+    !capabilities.packageManager.includes(options.packageManager)
+  ) {
+    throw new Error(
+      `${command} supports package managers: ${capabilities.packageManager.join(', ')}`
+    );
+  }
+}
+
+function validateProjectName(target) {
+  if (!target) throw new Error('Project name is required.');
+  if (!/^[A-Za-z0-9._-]+$/.test(target)) {
+    throw new Error('Invalid project name. Use only letters, numbers, dots, underscores, and hyphens.');
+  }
+}
+
+module.exports = {
+  parseArgs,
+  validateCommandFlags,
+  validateFrameworkOptions,
+  validateProjectName,
+};

package/src/utils/interpolate.js

@@ -0,0 +1,10 @@
+// Copyright (c) 2026 bachbnt
+
+function interpolate(value, context, label) {
+  return value.replace(/\{([A-Za-z][A-Za-z0-9_]*)\}/g, (match, key) => {
+    if (context[key] === undefined) throw new Error(`Unknown ${label}: ${key}`);
+    return String(context[key]);
+  });
+}
+
+module.exports = { interpolate };