@bachbntdev/devcmd 0.0.0-stage → 2.7.1

package/src/handlers/system.js

@@ -0,0 +1,135 @@
+// Copyright (c) 2026 bachbnt
+
+const { CONFIG_FILE, OPENERS_DIR, PROJECTS_FILE, RECIPES_DIR, VERSION, frameworkDefinitions } = require('../config');
+const { setConfigValue } = require('../config/user');
+const { getExistingProjects } = require('../projects/recent');
+const { checkTools } = require('../runner/check');
+const { loadRecipeFile } = require('../recipes');
+const { loadOpenerFile } = require('../openers');
+const { executeCommands } = require('../runtime/execute');
+
+const PACKAGE_SPEC = '@bachbntdev/devcmd@latest';
+
+function printConfig(p, config) {
+  p.note(JSON.stringify(config, null, 2), `Config: ${CONFIG_FILE}`);
+}
+
+function handleConfig(context) {
+  const { p, positionals, config } = context;
+  if (positionals.length === 0 || (positionals[0] === 'show' && positionals.length === 1)) {
+    printConfig(p, config);
+    p.outro('Use: dev config set <key> <value>');
+    return 0;
+  }
+  if (positionals[0] === 'set' && positionals.length === 3) {
+    printConfig(p, setConfigValue(positionals[1], positionals[2]));
+    p.outro('Configuration saved.');
+    return 0;
+  }
+  throw new Error('Usage: dev config [show] or dev config set <key> <value>');
+}
+
+async function handleUpdate(context) {
+  const { p, pc, options } = context;
+  p.log.info(`Current version: ${VERSION}`);
+  return executeCommands(p, pc, [
+    { executable: 'npm', args: ['install', '--global', PACKAGE_SPEC] },
+  ], { command: 'update' }, options);
+}
+
+function handleDoctor(context) {
+  const { p, pc, config } = context;
+  const checks = checkTools(config);
+  p.note(checks.map((check) => {
+    const marker = check.found ? pc.green('OK') : check.required ? pc.red('MISSING') : pc.yellow('optional');
+    return `${marker.padEnd(18)} ${check.name.padEnd(18)} ${check.version || check.path || ''}`;
+  }).join('\n'), 'Development environment');
+  const hints = checks.filter((check) => !check.found && check.hint);
+  if (hints.length > 0) {
+    p.note(hints.map((check) => `${check.name.padEnd(18)} ${check.hint}`).join('\n'), 'How to install missing tools');
+  }
+  const missing = checks.filter((check) => check.required && !check.found);
+  p.outro(missing.length ? 'Required tools are missing.' : 'DevCmd is ready.');
+  return missing.length ? 1 : 0;
+}
+
+function handleProjects(context) {
+  const { p } = context;
+  const projects = getExistingProjects();
+  if (projects.length === 0) {
+    p.outro('No recent projects yet.');
+    return 0;
+  }
+  p.note(
+    projects.map((project, index) => `${index + 1}. ${project.name} [${project.type}]\n   ${project.path}`).join('\n'),
+    `Recent projects: ${PROJECTS_FILE}`
+  );
+  p.outro(`${projects.length} project(s).`);
+  return 0;
+}
+
+function handleInfo(context) {
+  const { p, pc } = context;
+  const definitions = context.frameworkDefinitions || frameworkDefinitions;
+  p.note(
+    Object.entries(definitions)
+      .map(([name, definition]) => {
+        const source = definition.source === 'user' ? ' [user recipe]' : '';
+        return `${pc.bold(name)}: ${definition.description}${source}`;
+      })
+      .join('\n'),
+    'Supported frameworks'
+  );
+  p.outro('Run dev help for usage and options.');
+  return 0;
+}
+
+function handleRecipes(context) {
+  const { p, positionals, recipeRegistry } = context;
+  if (positionals.length === 0 || (positionals[0] === 'list' && positionals.length === 1)) {
+    const lines = [...recipeRegistry.values()].map(
+      (recipe) => `${recipe.name.padEnd(20)} [${recipe.source}] ${recipe.description}`
+    );
+    p.note(lines.join('\n'), 'Available recipes');
+    p.outro(`User recipe directory: ${RECIPES_DIR}`);
+    return 0;
+  }
+  if (positionals[0] === 'validate' && positionals.length === 2) {
+    const recipes = loadRecipeFile(positionals[1], 'user');
+    p.note(recipes.map((recipe) => `${recipe.name}: ${recipe.description}`).join('\n'), 'Valid recipes');
+    p.outro(`${recipes.length} recipe(s) validated.`);
+    return 0;
+  }
+  throw new Error('Usage: dev recipes [list] or dev recipes validate <file>');
+}
+
+function handleOpeners(context) {
+  const { p, positionals, openerRegistry } = context;
+  if (positionals.length === 0 || (positionals[0] === 'list' && positionals.length === 1)) {
+    const lines = [...openerRegistry.values()].map((opener) => {
+      const aliases = opener.aliases?.length ? ` aliases: ${opener.aliases.join(', ')}` : '';
+      return `${opener.name.padEnd(20)} [${opener.source}] ${opener.description}${aliases}`;
+    });
+    p.note(lines.join('\n'), 'Available openers');
+    p.outro(`User opener directory: ${OPENERS_DIR}`);
+    return 0;
+  }
+  if (positionals[0] === 'validate' && positionals.length === 2) {
+    const openers = loadOpenerFile(positionals[1], 'user');
+    p.note(openers.map((opener) => `${opener.name}: ${opener.description}`).join('\n'), 'Valid openers');
+    p.outro(`${openers.length} opener(s) validated.`);
+    return 0;
+  }
+  throw new Error('Usage: dev openers [list] or dev openers validate <file>');
+}
+
+module.exports = {
+  handleConfig,
+  handleDoctor,
+  handleInfo,
+  handleOpeners,
+  handleProjects,
+  handleRecipes,
+  handleUpdate,
+  printConfig,
+};

package/src/handlers/tools.js

@@ -0,0 +1,66 @@
+// Copyright (c) 2026 bachbnt
+
+const path = require('path');
+const { buildDockerCommands } = require('../commands/docker');
+const { checkEnv, initEnv } = require('../commands/env');
+const { detectProject } = require('../projects/detect');
+const { executeCommands } = require('../runtime/execute');
+
+function resolveRoot(projectPath, context) {
+  if (projectPath) return path.resolve(projectPath);
+  try {
+    return detectProject(process.cwd(), { registry: context.recipeRegistry }).root;
+  } catch {
+    return process.cwd();
+  }
+}
+
+function handleEnv(context) {
+  const { p, positionals, options } = context;
+  const subcommand = ['init', 'check'].includes(positionals[0]) ? positionals[0] : 'init';
+  const rest = ['init', 'check'].includes(positionals[0]) ? positionals.slice(1) : positionals;
+  if (rest.length > 1) throw new Error('Usage: dev env [init|check] [path]');
+  const root = resolveRoot(rest[0], context);
+
+  if (subcommand === 'check') {
+    const result = checkEnv(root);
+    if (result.ok) {
+      p.outro(`.env defines every variable from ${result.template}.`);
+      return 0;
+    }
+    p.note(result.missing.join('\n'), `Missing from .env (see ${result.template})`);
+    p.outro(`${result.missing.length} variable(s) missing.`);
+    return 1;
+  }
+  if (options.dryRun) {
+    p.outro(`Would create .env from the template in ${root} if it does not exist.`);
+    return 0;
+  }
+  const result = initEnv(root);
+  p.outro(result.created
+    ? `Created .env from ${result.template}. Fill in the values.`
+    : '.env already exists. Nothing was changed.');
+  return 0;
+}
+
+async function handleDocker(context) {
+  const { p, pc, positionals, options, config } = context;
+  if (positionals.length < 1 || positionals.length > 2) {
+    throw new Error('Usage: dev docker <up|down|build|ps|logs|restart> [path]');
+  }
+  const root = resolveRoot(positionals[1], context);
+  const commands = buildDockerCommands(positionals[0], root);
+  return executeCommands(p, pc, commands, {
+    command: 'docker',
+    action: positionals[0],
+    projectPath: root,
+    projectName: path.basename(root),
+    projectType: 'docker',
+    config,
+  }, { ...options, requirements: ['docker'] });
+}
+
+module.exports = {
+  handleDocker,
+  handleEnv,
+};

package/src/handlers/workflow.js

@@ -0,0 +1,121 @@
+// Copyright (c) 2026 bachbnt
+
+const path = require('path');
+const { buildLifecycleCommands, buildTaskCommands, listTasks } = require('../commands/lifecycle');
+const { LIFECYCLE_COMMANDS } = require('../constants');
+const { detectProject } = require('../projects/detect');
+const { describeProfile, isTrusted, trustProfile } = require('../projects/profile');
+const { formatSequence } = require('../runner/command');
+const { runParallel } = require('../runner/parallel');
+const { executeCommands } = require('../runtime/execute');
+
+const TASK_NAME = /^[A-Za-z0-9][A-Za-z0-9:_.-]*$/;
+const PARALLEL_ACTIONS = LIFECYCLE_COMMANDS.filter((action) => action !== 'open');
+
+function detect(projectPath, context) {
+  return detectProject(projectPath || process.cwd(), { registry: context.recipeRegistry });
+}
+
+function projectMetadata(project, command, config) {
+  return {
+    command,
+    projectName: project.name,
+    projectPath: project.root,
+    projectType: project.type,
+    config,
+  };
+}
+
+async function handleTask(context) {
+  const { p, pc, positionals, options, config } = context;
+  if (positionals.length > 2) throw new Error('Usage: dev task [name] [path]');
+  const [name, projectPath] = positionals;
+  const project = detect(projectPath, context);
+  if (!name) {
+    const tasks = listTasks(project);
+    if (tasks.length === 0) {
+      p.outro('No tasks found. Add scripts to package.json or tasks to .devcmd.json.');
+      return 0;
+    }
+    p.note(
+      tasks.map((task) => {
+        const description = task.description ? ` ${pc.dim(task.description)}` : '';
+        return `${task.name.padEnd(20)} [${task.source}]${description}`;
+      }).join('\n'),
+      `Tasks: ${project.name}`
+    );
+    p.outro('Use: dev task <name> [path]');
+    return 0;
+  }
+  if (!TASK_NAME.test(name)) throw new Error(`Invalid task name: ${name}`);
+  const commands = buildTaskCommands(project, name, { config, filter: options.filter });
+  return executeCommands(p, pc, commands, projectMetadata(project, 'task', config), options);
+}
+
+async function handleParallel(context) {
+  const { p, pc, positionals, options, config } = context;
+  const [action, ...paths] = positionals;
+  if (!PARALLEL_ACTIONS.includes(action) || paths.length === 0) {
+    throw new Error(`Usage: dev parallel <${PARALLEL_ACTIONS.join('|')}> <path> [path...]`);
+  }
+  const jobs = paths.map((projectPath) => {
+    const project = detect(projectPath, context);
+    return {
+      label: project.name || path.basename(project.root),
+      commands: buildLifecycleCommands(action, project, { config }),
+    };
+  });
+  const labels = new Set(jobs.map((job) => job.label));
+  if (labels.size !== jobs.length) {
+    jobs.forEach((job, index) => {
+      job.label = `${job.label}#${index + 1}`;
+    });
+  }
+  for (const job of jobs) p.log.step(`${pc.cyan(job.label)}: ${pc.yellow(formatSequence(job.commands))}`);
+  if (options.dryRun) {
+    p.outro('No command was executed.');
+    return 0;
+  }
+  const result = await runParallel(jobs);
+  const summary = result.results
+    .map((entry) => `${entry.ok ? pc.green('✔') : pc.red('✖')} ${entry.label}${entry.ok ? '' : ` (exit ${entry.exitCode})`}`)
+    .join('\n');
+  p.note(summary, `dev ${action}`);
+  p.outro(result.ok ? `${pc.green('✔')} All projects completed.` : `${pc.red('✖')} Some projects failed.`);
+  return result.exitCode;
+}
+
+async function handleTrust(context) {
+  const { p, pc, positionals, options, config } = context;
+  if (positionals.length > 1) throw new Error('Usage: dev trust [path]');
+  const project = detect(positionals[0], context);
+  if (!project.profile) throw new Error(`No .devcmd.json was found for ${project.root}.`);
+  const entries = describeProfile(project, { config });
+  p.note(
+    entries.length
+      ? entries.map((entry) => `${pc.bold(entry.label)}\n  ${formatSequence(entry.commands)}`).join('\n')
+      : 'The profile does not define any commands.',
+    project.profile.file
+  );
+  if (isTrusted(project.profile)) {
+    p.outro('This profile is already trusted.');
+    return 0;
+  }
+  if (!options.yes) {
+    const approved = await p.confirm({ message: 'Trust this profile and allow DevCmd to run these commands?' });
+    if (p.isCancel(approved) || !approved) {
+      p.cancel('Profile was not trusted.');
+      return 130;
+    }
+  }
+  trustProfile(project.profile);
+  p.outro('Profile trusted. It will need approval again if the file changes.');
+  return 0;
+}
+
+module.exports = {
+  PARALLEL_ACTIONS,
+  handleParallel,
+  handleTask,
+  handleTrust,
+};

package/src/mcp/processes.js

@@ -0,0 +1,164 @@
+// Copyright (c) 2026 bachbnt
+
+const { spawn } = require('child_process');
+const { formatSequence } = require('../runner/command');
+const { SIGNAL_EXIT_CODES } = require('../runner/process');
+
+const DEFAULT_MAX_LOG_BYTES = 256 * 1024;
+const DEFAULT_KILL_GRACE_MS = 3000;
+
+class ProcessManager {
+  constructor(options = {}) {
+    this.spawnImpl = options.spawnImpl || spawn;
+    this.maxLogBytes = options.maxLogBytes || DEFAULT_MAX_LOG_BYTES;
+    this.killGraceMs = options.killGraceMs ?? DEFAULT_KILL_GRACE_MS;
+    this.entries = new Map();
+    this.counter = 0;
+  }
+
+  start({ label, commands }) {
+    this.counter += 1;
+    const entry = {
+      id: `p${this.counter}`,
+      label,
+      commandLine: formatSequence(commands),
+      status: 'running',
+      exitCode: undefined,
+      startedAt: new Date().toISOString(),
+      log: '',
+      droppedChars: 0,
+      child: undefined,
+      stopRequested: false,
+    };
+    entry.done = new Promise((resolve) => {
+      entry.resolveDone = resolve;
+    });
+    this.entries.set(entry.id, entry);
+    this.runNext(entry, commands, 0);
+    return this.summary(entry);
+  }
+
+  runNext(entry, commands, index) {
+    if (entry.stopRequested) return this.finish(entry, 'stopped', undefined);
+    if (index >= commands.length) return this.finish(entry, 'exited', 0);
+    const command = commands[index];
+    let child;
+    try {
+      const spawnOptions = { shell: false, stdio: ['ignore', 'pipe', 'pipe'] };
+      if (command.cwd) spawnOptions.cwd = command.cwd;
+      child = this.spawnImpl(command.executable, command.args, spawnOptions);
+    } catch (error) {
+      this.append(entry, `${error.message}\n`);
+      return this.finish(entry, 'failed', error.code === 'ENOENT' ? 127 : 1);
+    }
+    entry.child = child;
+    child.stdout?.on('data', (data) => this.append(entry, data));
+    child.stderr?.on('data', (data) => this.append(entry, data));
+    let settled = false;
+    const settle = (callback) => {
+      if (settled) return;
+      settled = true;
+      entry.child = undefined;
+      callback();
+    };
+    child.once('error', (error) => settle(() => {
+      this.append(entry, `${error.message}\n`);
+      this.finish(entry, 'failed', error.code === 'ENOENT' ? 127 : 1);
+    }));
+    child.once('close', (code, signal) => settle(() => {
+      if (entry.stopRequested) this.finish(entry, 'stopped', code ?? SIGNAL_EXIT_CODES[signal]);
+      else if (signal) this.finish(entry, 'failed', SIGNAL_EXIT_CODES[signal] || 1);
+      else if (code === 0) this.runNext(entry, commands, index + 1);
+      else this.finish(entry, 'failed', code ?? 1);
+    }));
+  }
+
+  append(entry, data) {
+    entry.log += data.toString();
+    if (entry.log.length > this.maxLogBytes) {
+      const excess = entry.log.length - this.maxLogBytes;
+      entry.log = entry.log.slice(excess);
+      entry.droppedChars += excess;
+    }
+  }
+
+  finish(entry, status, exitCode) {
+    entry.status = status;
+    entry.exitCode = exitCode;
+    entry.endedAt = new Date().toISOString();
+    entry.resolveDone();
+  }
+
+  get(id) {
+    const entry = this.entries.get(id);
+    if (!entry) throw new Error(`Unknown process id: ${id}. Use list_processes to see running processes.`);
+    return entry;
+  }
+
+  summary(entry) {
+    return {
+      id: entry.id,
+      label: entry.label,
+      command: entry.commandLine,
+      status: entry.status,
+      exitCode: entry.exitCode,
+      startedAt: entry.startedAt,
+      endedAt: entry.endedAt,
+    };
+  }
+
+  list() {
+    return [...this.entries.values()].map((entry) => this.summary(entry));
+  }
+
+  logs(id, options = {}) {
+    const entry = this.get(id);
+    const tail = Number.isInteger(options.tail) && options.tail > 0 ? options.tail : 100;
+    const lines = entry.log.split('\n');
+    if (lines[lines.length - 1] === '') lines.pop();
+    return {
+      ...this.summary(entry),
+      truncated: entry.droppedChars > 0 || lines.length > tail,
+      output: lines.slice(-tail).join('\n'),
+    };
+  }
+
+  async stop(id) {
+    const entry = this.get(id);
+    if (entry.status !== 'running') return this.summary(entry);
+    entry.stopRequested = true;
+    const child = entry.child;
+    if (child) {
+      try {
+        child.kill('SIGTERM');
+      } catch {}
+      const timer = setTimeout(() => {
+        try {
+          if (entry.status === 'running') child.kill('SIGKILL');
+        } catch {}
+      }, this.killGraceMs);
+      timer.unref?.();
+      await Promise.race([
+        entry.done,
+        new Promise((resolve) => {
+          const wait = setTimeout(resolve, this.killGraceMs + 1000);
+          wait.unref?.();
+        }),
+      ]);
+      clearTimeout(timer);
+    }
+    return this.summary(entry);
+  }
+
+  stopAll() {
+    for (const entry of this.entries.values()) {
+      if (entry.status !== 'running') continue;
+      entry.stopRequested = true;
+      try {
+        entry.child?.kill('SIGTERM');
+      } catch {}
+    }
+  }
+}
+
+module.exports = { ProcessManager };

package/src/mcp/server.js

@@ -0,0 +1,32 @@
+// Copyright (c) 2026 bachbnt
+
+const { Server } = require('@modelcontextprotocol/sdk/server/index.js');
+const { StdioServerTransport } = require('@modelcontextprotocol/sdk/server/stdio.js');
+const {
+  CallToolRequestSchema,
+  ListToolsRequestSchema,
+} = require('@modelcontextprotocol/sdk/types.js');
+const { VERSION } = require('../config');
+const { TOOLS, callTool, defaultProcesses } = require('./tools');
+
+async function startMcpServer() {
+  const server = new Server(
+    { name: 'devcmd', version: VERSION },
+    { capabilities: { tools: {} } }
+  );
+
+  server.setRequestHandler(ListToolsRequestSchema, async () => ({ tools: TOOLS }));
+
+  server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const { name, arguments: args = {} } = request.params;
+    return callTool(name, args);
+  });
+
+  server.onclose = () => defaultProcesses.stopAll();
+  process.once('exit', () => defaultProcesses.stopAll());
+
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+}
+
+module.exports = { TOOLS, callTool, startMcpServer };