codemini-cli 0.1.13 → 0.1.15

package/src/core/shell.js

@@ -1,6 +1,79 @@
-import { spawn } from 'node:child_process';
+import { spawn, spawnSync } from 'node:child_process';
 
-function resolveShell(defaultShell) {
+const LONG_RUNNING_COMMAND_RE =
+  /\b(npm\s+(?:run\s+)?(?:start|dev)\b|pnpm\s+(?:run\s+)?(?:start|dev)\b|yarn\s+(?:start|dev)\b|vite\b|next\s+dev\b|webpack\s+serve\b|python\s+-m\s+http\.server\b|serve\b|java\s+-jar\b|mvn(?:w)?\s+spring-boot:run\b|gradle(?:w)?\s+bootRun\b|gradle(?:w)?\s+run\b|java\b.*\bserver\b|dotnet\s+run\b|go\s+run\b.*\b(server|cmd\/server|main\.go)\b|air\b|cargo\s+run\b.*\b(server|api|web)\b|cargo\s+watch\s+-x\s+run\b)/i;
+const GENERIC_LONG_RUNNING_HINT_RE = /\b(start|serve|server|dev|preview|watch)\b/i;
+const READY_OUTPUT_PATTERNS = [
+  /\bready\b/i,
+  /\bcompiled successfully\b/i,
+  /\blocal:\s*https?:\/\//i,
+  /\blistening on\b/i,
+  /\bserver running\b/i,
+  /\brunning at\b/i,
+  /\bserving at\b/i,
+  /\bstarted\b.*\bin\b/i,
+  /\bstarted\s+[A-Za-z0-9_$.-]+\s+in\b/i,
+  /\btomcat started on port\(s\):/i,
+  /\bnetty started on port/i,
+  /\bnow listening on:\s*https?:\/\//i,
+  /\bapplication started\./i,
+  /\bserving http on\b/i,
+  /\bstarting development server at\b/i,
+  /\bactix web server running on\b/i,
+  /\bhttp:\/\/127\.0\.0\.1\b/i,
+  /\bhttp:\/\/localhost\b/i
+];
+const AUTO_STOP_GRACE_MS = 150;
+const LONG_RUNNING_STARTUP_WINDOW_MS = 1500;
+
+export function isLikelyLongRunningCommand(command) {
+  const value = String(command || '');
+  return LONG_RUNNING_COMMAND_RE.test(value) || GENERIC_LONG_RUNNING_HINT_RE.test(value);
+}
+
+export function hasReadyOutput(text) {
+  const value = String(text || '');
+  return READY_OUTPUT_PATTERNS.some((pattern) => pattern.test(value));
+}
+
+function collectDescendantPids(rootPid, seen = new Set()) {
+  const pid = Number(rootPid);
+  if (!Number.isInteger(pid) || pid <= 0 || seen.has(pid) || process.platform === 'win32') {
+    return [];
+  }
+  seen.add(pid);
+  const result = spawnSync('ps', ['-o', 'pid=', '--ppid', String(pid)], { encoding: 'utf8' });
+  if (result.status !== 0 || !result.stdout) return [];
+  const directChildren = result.stdout
+    .split('\n')
+    .map((value) => Number(String(value || '').trim()))
+    .filter((value) => Number.isInteger(value) && value > 0);
+  const descendants = [];
+  for (const childPid of directChildren) {
+    if (seen.has(childPid)) continue;
+    descendants.push(childPid);
+    descendants.push(...collectDescendantPids(childPid, seen));
+  }
+  return descendants;
+}
+
+export function terminateChild(child, signal = 'SIGTERM') {
+  if (!child) return;
+  const pid = Number(child.pid);
+  if (process.platform !== 'win32' && Number.isInteger(pid) && pid > 0) {
+    const descendants = collectDescendantPids(pid);
+    for (const targetPid of descendants.reverse()) {
+      try {
+        process.kill(targetPid, signal);
+      } catch {}
+    }
+  }
+  try {
+    child.kill(signal);
+  } catch {}
+}
+
+export function resolveShell(defaultShell) {
   if (process.platform === 'win32') {
     if (defaultShell === 'cmd') {
       return { command: 'cmd.exe', args: ['/d', '/s', '/c'] };
@@ -30,9 +103,13 @@ export function runShellCommand({
   timeoutMs = 120000
 }) {
   const shellSpec = resolveShell(shell);
+  const shellCommand =
+    process.platform !== 'win32' && /(?:^|\/)bash(?:\.exe)?$/i.test(shellSpec.command)
+      ? `exec ${command}`
+      : command;
 
   return new Promise((resolve, reject) => {
-    const child = spawn(shellSpec.command, [...shellSpec.args, command], {
+    const child = spawn(shellSpec.command, [...shellSpec.args, shellCommand], {
       cwd,
       stdio: ['ignore', 'pipe', 'pipe']
     });
@@ -40,32 +117,81 @@ export function runShellCommand({
     let stdout = '';
     let stderr = '';
     let timedOut = false;
+    let autoStopped = false;
+    let stopReason = '';
+    let finalized = false;
+    const longRunningCommand = isLikelyLongRunningCommand(command);
+    const autoStopWindowMs = longRunningCommand
+      ? Math.min(LONG_RUNNING_STARTUP_WINDOW_MS, Math.max(350, Math.floor(timeoutMs * 0.6)))
+      : 0;
+
+    const finalizeResolve = (value) => {
+      if (finalized) return;
+      finalized = true;
+      clearTimeout(timer);
+      if (autoStopTimer) clearTimeout(autoStopTimer);
+      resolve(value);
+    };
+
+    const finalizeReject = (error) => {
+      if (finalized) return;
+      finalized = true;
+      clearTimeout(timer);
+      if (autoStopTimer) clearTimeout(autoStopTimer);
+      reject(error);
+    };
 
     const timer = setTimeout(() => {
       timedOut = true;
-      child.kill('SIGTERM');
+      terminateChild(child, 'SIGTERM');
     }, timeoutMs);
+    const autoStopTimer =
+      autoStopWindowMs > 0
+        ? setTimeout(() => {
+            finalizeAutoStop('startup_window');
+          }, autoStopWindowMs)
+        : null;
+
+    const finalizeAutoStop = (reason) => {
+      if (timedOut || autoStopped || finalized) return;
+      autoStopped = true;
+      stopReason = reason;
+      terminateChild(child, 'SIGTERM');
+      setTimeout(() => {
+        terminateChild(child, 'SIGKILL');
+      }, AUTO_STOP_GRACE_MS);
+      finalizeResolve({ code: 0, stdout, stderr, auto_stopped: true, stop_reason: stopReason });
+    };
 
     child.stdout.on('data', (chunk) => {
       stdout += chunk.toString();
+      if (longRunningCommand && hasReadyOutput(stdout)) {
+        finalizeAutoStop('ready_output');
+      }
     });
 
     child.stderr.on('data', (chunk) => {
       stderr += chunk.toString();
+      if (longRunningCommand && hasReadyOutput(stderr)) {
+        finalizeAutoStop('ready_output');
+      }
     });
 
     child.on('error', (err) => {
-      clearTimeout(timer);
-      reject(err);
+      finalizeReject(err);
     });
 
     child.on('close', (code) => {
-      clearTimeout(timer);
+      if (finalized) return;
       if (timedOut) {
-        reject(new Error(`Command timed out after ${timeoutMs}ms`));
+        finalizeReject(new Error(`Command timed out after ${timeoutMs}ms`));
+        return;
+      }
+      if (autoStopped) {
+        finalizeResolve({ code: 0, stdout, stderr, auto_stopped: true, stop_reason: stopReason });
         return;
       }
-      resolve({ code, stdout, stderr });
+      finalizeResolve({ code, stdout, stderr });
     });
   });
 }

package/src/core/tools.js

@@ -1,7 +1,16 @@
 import fs from 'node:fs/promises';
 import path from 'node:path';
 import crypto from 'node:crypto';
-import { isDangerousCommand, runShellCommand } from './shell.js';
+import { spawn } from 'node:child_process';
+import net from 'node:net';
+import {
+  hasReadyOutput,
+  isDangerousCommand,
+  isLikelyLongRunningCommand,
+  resolveShell,
+  runShellCommand,
+  terminateChild
+} from './shell.js';
 import { evaluateCommandPolicy } from './command-policy.js';
 
 const SKIP_DIRS = new Set(['.git', 'node_modules', '.coder', '.codemini-cli', 'dist', 'coverage']);
@@ -46,6 +55,11 @@ const LANGUAGE_FILE_TYPES = {
   shell: ['sh', 'ps1'],
   yaml: ['yml', 'yaml']
 };
+const SERVICE_RECENT_LOG_LIMIT = 80;
+const SERVICE_STARTUP_POLL_MS = 150;
+const serviceRegistry = new Map();
+let serviceCounter = 0;
+let serviceLogCursorCounter = 0;
 
 function resolveInWorkspace(root, targetPath = '.') {
   const absRoot = path.resolve(root);
@@ -509,6 +523,9 @@ async function runCommand(root, config, args) {
   if (!command.trim()) {
     throw new Error('run_command requires command');
   }
+  if (isLikelyLongRunningCommand(command)) {
+    throw new Error('Command looks like a long-running service. Use start_service instead of run_command.');
+  }
   if (
     !config.policy.allow_dangerous_commands &&
     isDangerousCommand(command, config.policy.blocked_command_patterns)
@@ -532,6 +549,300 @@ async function runCommand(root, config, args) {
   return { ...result, command };
 }
 
+function nextServiceId() {
+  serviceCounter += 1;
+  return `svc_${String(serviceCounter).padStart(3, '0')}`;
+}
+
+function normalizeSuccessMatchers(items = []) {
+  if (!Array.isArray(items)) return [];
+  return items.map((item) => String(item || '').trim()).filter(Boolean);
+}
+
+function shellCommandForService(command, shellSpec) {
+  return process.platform !== 'win32' && /(?:^|\/)bash(?:\.exe)?$/i.test(shellSpec.command)
+    ? `exec ${command}`
+    : command;
+}
+
+function appendRecentLogs(service, chunk) {
+  const lines = String(chunk || '')
+    .split(/\r?\n/)
+    .map((line) => trimLinePreview(line, 220))
+    .filter(Boolean);
+  if (lines.length === 0) return;
+  for (const line of lines) {
+    serviceLogCursorCounter += 1;
+    service.recentLogs.push({ cursor: serviceLogCursorCounter, line });
+  }
+  if (service.recentLogs.length > SERVICE_RECENT_LOG_LIMIT) {
+    service.recentLogs.splice(0, service.recentLogs.length - SERVICE_RECENT_LOG_LIMIT);
+  }
+}
+
+function matchesServiceSuccess(service, text) {
+  const value = String(text || '');
+  if (!value) return false;
+  if (hasReadyOutput(value)) return true;
+  return service.successMatchers.some((matcher) => value.toLowerCase().includes(matcher.toLowerCase()));
+}
+
+function markServiceReady(service, source = 'output') {
+  if (service.startupConfirmed) return;
+  service.startupConfirmed = true;
+  service.startupSource = source;
+  service.status = 'running';
+}
+
+function serviceUrlForPort(port) {
+  const portNumber = Number(port);
+  return Number.isInteger(portNumber) && portNumber > 0 ? `http://127.0.0.1:${portNumber}` : '';
+}
+
+function normalizeHttpProbe(value) {
+  if (!value || typeof value !== 'object') return null;
+  const url = String(value.url || '').trim();
+  if (!url) return null;
+  const expectStatus = Number(value.expect_status ?? value.expectStatus ?? 200);
+  return {
+    url,
+    expect_status: Number.isInteger(expectStatus) ? expectStatus : 200
+  };
+}
+
+function snapshotService(service, tail = 12) {
+  const recentLogs = Array.isArray(service.recentLogs)
+    ? service.recentLogs.slice(-Math.max(1, tail)).map((item) => item.line)
+    : [];
+  const latestCursor =
+    Array.isArray(service.recentLogs) && service.recentLogs.length > 0
+      ? service.recentLogs[service.recentLogs.length - 1].cursor
+      : 0;
+  return {
+    task_id: service.taskId,
+    pid: service.child?.pid || null,
+    command: service.command,
+    cwd: service.cwd,
+    status: service.status,
+    startup_confirmed: service.startupConfirmed,
+    startup_source: service.startupSource || '',
+    http_probe: service.httpProbe || undefined,
+    url: serviceUrlForPort(service.portProbe) || undefined,
+    recent_logs: recentLogs,
+    log_cursor: latestCursor,
+    exit_code: service.exitCode ?? undefined,
+    signal: service.signal ?? undefined,
+    duration_ms: Date.now() - service.startedAt
+  };
+}
+
+function listServiceSnapshots() {
+  return Array.from(serviceRegistry.values()).map((service) => snapshotService(service, 4));
+}
+
+function probePortOnce(port, host = '127.0.0.1', timeoutMs = 250) {
+  return new Promise((resolve) => {
+    const socket = new net.Socket();
+    let settled = false;
+    const finish = (value) => {
+      if (settled) return;
+      settled = true;
+      socket.destroy();
+      resolve(value);
+    };
+    socket.setTimeout(timeoutMs);
+    socket.once('connect', () => finish(true));
+    socket.once('timeout', () => finish(false));
+    socket.once('error', () => finish(false));
+    socket.connect(Number(port), host);
+  });
+}
+
+async function probeHttpOnce(httpProbe, timeoutMs = 400) {
+  if (!httpProbe?.url) return false;
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    const response = await fetch(httpProbe.url, {
+      method: 'GET',
+      signal: controller.signal
+    });
+    return response.status === Number(httpProbe.expect_status || 200);
+  } catch {
+    return false;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+async function startService(root, config, args) {
+  const command = String(args?.command || args?.cmd || '').trim();
+  if (!command) throw new Error('start_service requires command');
+  if (
+    !config.policy.allow_dangerous_commands &&
+    isDangerousCommand(command, config.policy.blocked_command_patterns)
+  ) {
+    throw new Error('Command blocked by policy');
+  }
+  const check = evaluateCommandPolicy(command, config, root);
+  if (!check.allowed) {
+    throw new Error(
+      `Command blocked by safe mode: ${check.reason}${check.suggestion ? ` | ${check.suggestion}` : ''}`
+    );
+  }
+
+  const shellSpec = resolveShell(config.shell.default);
+  const taskId = nextServiceId();
+  const startupTimeoutMs = Math.max(250, Number(args?.startup_timeout_ms || args?.startupTimeoutMs || 20000));
+  const successMatchers = normalizeSuccessMatchers(args?.success_matchers || args?.successMatchers);
+  const portProbe = Number(args?.port_probe || args?.portProbe || 0) || 0;
+  const httpProbe = normalizeHttpProbe(args?.http_probe || args?.httpProbe);
+  const service = {
+    taskId,
+    command,
+    cwd: root,
+    child: spawn(shellSpec.command, [...shellSpec.args, shellCommandForService(command, shellSpec)], {
+      cwd: root,
+      stdio: ['ignore', 'pipe', 'pipe']
+    }),
+    startedAt: Date.now(),
+    status: 'starting',
+    startupConfirmed: false,
+    startupSource: '',
+    successMatchers,
+    portProbe,
+    httpProbe,
+    recentLogs: [],
+    exitCode: null,
+    signal: null
+  };
+  serviceRegistry.set(taskId, service);
+
+  service.closePromise = new Promise((resolve) => {
+    service.child.on('close', (code, signal) => {
+      service.exitCode = code;
+      service.signal = signal;
+      service.status = service.status === 'stopped' ? 'stopped' : 'exited';
+      resolve();
+    });
+  });
+
+  const onOutput = (chunk) => {
+    appendRecentLogs(service, chunk);
+    if (matchesServiceSuccess(service, chunk)) {
+      markServiceReady(service, 'output');
+      if (service._finishStartup) service._finishStartup();
+    }
+  };
+  service.child.stdout.on('data', onOutput);
+  service.child.stderr.on('data', onOutput);
+  service.child.on('error', (error) => {
+    appendRecentLogs(service, error?.message || String(error));
+    service.status = 'exited';
+    if (service._finishStartup) service._finishStartup();
+  });
+
+  await new Promise((resolve) => {
+    let settled = false;
+    const finish = () => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timeoutHandle);
+      clearInterval(portHandle);
+      clearInterval(httpHandle);
+      service._finishStartup = null;
+      resolve();
+    };
+    service._finishStartup = finish;
+    if (service.startupConfirmed || service.status === 'exited') {
+      finish();
+      return;
+    }
+    const timeoutHandle = setTimeout(() => {
+      if (service.status === 'starting') {
+        if (!service.startupConfirmed) {
+          markServiceReady(service, 'startup_window');
+        } else {
+          service.status = 'running';
+        }
+      }
+      finish();
+    }, startupTimeoutMs);
+    const portHandle =
+      portProbe > 0
+        ? setInterval(async () => {
+            const open = await probePortOnce(portProbe);
+            if (open) {
+              markServiceReady(service, 'port_probe');
+              finish();
+            }
+          }, SERVICE_STARTUP_POLL_MS)
+        : null;
+    const httpHandle =
+      httpProbe
+        ? setInterval(async () => {
+            const ok = await probeHttpOnce(httpProbe);
+            if (ok) {
+              markServiceReady(service, 'http_probe');
+              finish();
+            }
+          }, SERVICE_STARTUP_POLL_MS)
+        : null;
+    service.child.once('close', () => finish());
+  });
+
+  if (service.status === 'starting') {
+    service.status = 'running';
+  }
+  return snapshotService(service);
+}
+
+function getServiceOrThrow(taskId) {
+  const service = serviceRegistry.get(String(taskId || '').trim());
+  if (!service) throw new Error(`Unknown service task: ${taskId}`);
+  return service;
+}
+
+async function getServiceStatus(_root, args) {
+  const service = getServiceOrThrow(args?.task_id || args?.taskId);
+  return snapshotService(service);
+}
+
+async function listServices() {
+  return {
+    services: listServiceSnapshots()
+  };
+}
+
+async function getServiceLogs(_root, args) {
+  const service = getServiceOrThrow(args?.task_id || args?.taskId);
+  const tail = Math.max(1, Math.min(200, Number(args?.tail || 40)));
+  const afterCursor = Math.max(0, Number(args?.after_cursor || args?.afterCursor || 0));
+  const filtered = afterCursor > 0 ? service.recentLogs.filter((item) => item.cursor > afterCursor) : service.recentLogs;
+  const selected = filtered.slice(-tail);
+  return {
+    task_id: service.taskId,
+    status: service.status,
+    recent_logs: selected.map((item) => item.line),
+    next_cursor: selected.length > 0 ? selected[selected.length - 1].cursor : afterCursor
+  };
+}
+
+async function stopService(_root, args) {
+  const service = getServiceOrThrow(args?.task_id || args?.taskId);
+  if (service.status === 'stopped' || service.status === 'exited') {
+    return { ...snapshotService(service), stopped: true };
+  }
+  service.status = 'stopped';
+  terminateChild(service.child, 'SIGTERM');
+  setTimeout(() => terminateChild(service.child, 'SIGKILL'), 200);
+  await Promise.race([
+    service.closePromise,
+    new Promise((resolve) => setTimeout(resolve, 500))
+  ]);
+  return { ...snapshotService(service), stopped: true };
+}
+
 async function searchCode(root, args) {
   const query = String(args?.query || args?.symbol || '').trim();
   if (!query) throw new Error('search_code requires query');
@@ -794,17 +1105,55 @@ async function openTarget(root, args) {
   };
 }
 
-async function editTarget(root, args) {
+function normalizeEditTargetArgs(args = {}) {
   const file = String(args?.file || args?.path || '').trim();
-  const edit = args?.edit || {};
+  const nestedEdit = args?.edit && typeof args.edit === 'object' ? args.edit : null;
+  if (nestedEdit) {
+    return {
+      file,
+      edit: nestedEdit
+    };
+  }
+  return {
+    file,
+    edit: {
+      kind: args?.kind,
+      target: args?.target,
+      new_content: args?.new_content ?? args?.content,
+      old_text: args?.old_text,
+      new_text: args?.new_text,
+      anchor_text: args?.anchor_text,
+      content: args?.content
+    }
+  };
+}
+
+async function editTarget(root, args) {
+  const normalized = normalizeEditTargetArgs(args);
+  const file = normalized.file;
+  const edit = normalized.edit || {};
   const kind = String(edit.kind || '').trim();
   if (!file || !kind) throw new Error('edit_target requires file and edit.kind');
   if (kind === 'replace_block') {
-    return replaceBlock(root, {
-      path: file,
-      target: edit.target,
-      new_content: edit.new_content
-    });
+    try {
+      return await replaceBlock(root, {
+        path: file,
+        target: edit.target,
+        new_content: edit.new_content
+      });
+    } catch (error) {
+      if (!/old_hash mismatch/i.test(String(error?.message || ''))) throw error;
+      const validation = await validateEdit(root, {
+        path: file,
+        kind: 'replace_block',
+        target: edit.target
+      });
+      return replaceBlock(root, {
+        path: file,
+        target: validation.target,
+        new_content: edit.new_content
+      });
+    }
   }
   if (kind === 'replace_text') {
     return replaceText(root, {
@@ -1071,7 +1420,7 @@ export function getBuiltinTools({ workspaceRoot = process.cwd(), config }) {
       type: 'function',
       function: {
         name: 'run_command',
-        description: 'Execute a shell command in workspace',
+        description: 'Execute a one-shot shell command in workspace. Do not use for long-running services.',
         parameters: {
           type: 'object',
           properties: {
@@ -1080,6 +1429,88 @@ export function getBuiltinTools({ workspaceRoot = process.cwd(), config }) {
           required: ['command']
         }
       }
+    },
+    {
+      type: 'function',
+      function: {
+        name: 'start_service',
+        description: 'Start a long-running local service and return a compact service handle instead of blocking on process exit.',
+        parameters: {
+          type: 'object',
+          properties: {
+            command: { type: 'string' },
+            startup_timeout_ms: { type: 'number' },
+            success_matchers: {
+              type: 'array',
+              items: { type: 'string' }
+            },
+            port_probe: { type: 'number' },
+            http_probe: {
+              type: 'object',
+              properties: {
+                url: { type: 'string' },
+                expect_status: { type: 'number' }
+              }
+            }
+          },
+          required: ['command']
+        }
+      }
+    },
+    {
+      type: 'function',
+      function: {
+        name: 'list_services',
+        description: 'List all tracked local services and their compact current status.',
+        parameters: {
+          type: 'object',
+          properties: {}
+        }
+      }
+    },
+    {
+      type: 'function',
+      function: {
+        name: 'get_service_status',
+        description: 'Get the current status of a previously started service.',
+        parameters: {
+          type: 'object',
+          properties: {
+            task_id: { type: 'string' }
+          },
+          required: ['task_id']
+        }
+      }
+    },
+    {
+      type: 'function',
+      function: {
+        name: 'get_service_logs',
+        description: 'Read recent logs from a previously started service.',
+        parameters: {
+          type: 'object',
+          properties: {
+            task_id: { type: 'string' },
+            tail: { type: 'number' },
+            after_cursor: { type: 'number' }
+          },
+          required: ['task_id']
+        }
+      }
+    },
+    {
+      type: 'function',
+      function: {
+        name: 'stop_service',
+        description: 'Stop a previously started service.',
+        parameters: {
+          type: 'object',
+          properties: {
+            task_id: { type: 'string' }
+          },
+          required: ['task_id']
+        }
+      }
     }
   ];
 
@@ -1096,6 +1527,11 @@ export function getBuiltinTools({ workspaceRoot = process.cwd(), config }) {
     insert_before: (args) => insertRelative(workspaceRoot, args, 'insert_before'),
     insert_after: (args) => insertRelative(workspaceRoot, args, 'insert_after'),
     generate_diff: (args) => generateDiff(workspaceRoot, args),
+    start_service: (args) => startService(workspaceRoot, config, args),
+    list_services: () => listServices(workspaceRoot),
+    get_service_status: (args) => getServiceStatus(workspaceRoot, args),
+    get_service_logs: (args) => getServiceLogs(workspaceRoot, args),
+    stop_service: (args) => stopService(workspaceRoot, args),
     read_file: (args) =>
       readFile(workspaceRoot, {
         ...args,