z-clean 0.1.1 → 0.3.0

package/src/installer/launchd.js

@@ -4,48 +4,58 @@ const fs = require('fs');
 const path = require('path');
 const os = require('os');
 const { execSync } = require('child_process');
+const { LOCAL_BIN_HINT, resolveZcleanBin } = require('./bin-path');
 
 const PLIST_NAME = 'com.zclean.hourly';
 const PLIST_DIR = path.join(os.homedir(), 'Library', 'LaunchAgents');
 const PLIST_PATH = path.join(PLIST_DIR, `${PLIST_NAME}.plist`);
 
 /**
- * Resolve the full path to the zclean binary.
- * Tries: npx global, npm global, local install.
+ * Resolve the active nvm node bin path, if nvm is installed.
+ * Returns the path or null.
  */
-function resolveZcleanBin() {
-  // If installed globally via npm
+function resolveNvmNodeBin() {
+  const nvmDir = path.join(os.homedir(), '.nvm', 'versions', 'node');
   try {
-    const npmBin = execSync('npm bin -g', { encoding: 'utf-8', timeout: 5000 }).trim();
-    const globalPath = path.join(npmBin, 'zclean');
-    if (fs.existsSync(globalPath)) return globalPath;
-  } catch { /* ignore */ }
-
-  // Check common locations
-  const candidates = [
-    path.join(os.homedir(), '.local', 'bin', 'zclean'),
-    '/usr/local/bin/zclean',
-    path.join(os.homedir(), 'node_modules', '.bin', 'zclean'),
-  ];
-
-  for (const candidate of candidates) {
-    if (fs.existsSync(candidate)) return candidate;
+    if (!fs.existsSync(nvmDir)) return null;
+    // Use the currently running node's path if it's under .nvm
+    const nodeBin = process.execPath;
+    if (nodeBin.includes('.nvm')) {
+      return path.dirname(nodeBin);
+    }
+    // Fallback: find the default version directory
+    const versions = fs.readdirSync(nvmDir).filter((d) => d.startsWith('v')).sort().reverse();
+    if (versions.length > 0) {
+      return path.join(nvmDir, versions[0], 'bin');
+    }
+  } catch {
+    // ignore
   }
-
-  // Fallback to npx
-  return 'npx zclean';
+  return null;
 }
 
 /**
  * Generate the launchd plist XML.
  */
 function generatePlist(binPath) {
-  const parts = binPath.split(' ');
-  const programArgs = parts
-    .concat(['--yes'])
-    .map((arg) => `      <string>${arg}</string>`)
+  const programArgs = [binPath, '--yes']
+    .map((arg) => `      <string>${escapeXml(arg)}</string>`)
     .join('\n');
 
+  // Build PATH with nvm node bin if available
+  const pathParts = [
+    '/usr/local/bin',
+    '/usr/bin',
+    '/bin',
+    '/opt/homebrew/bin',
+    path.join(os.homedir(), '.local', 'bin'),
+  ];
+  const nvmBin = resolveNvmNodeBin();
+  if (nvmBin) {
+    pathParts.push(nvmBin);
+  }
+  const envPath = pathParts.join(':');
+
   return `<?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
 <plist version="1.0">
@@ -73,7 +83,7 @@ ${programArgs}
     <key>EnvironmentVariables</key>
     <dict>
         <key>PATH</key>
-        <string>/usr/local/bin:/usr/bin:/bin:/opt/homebrew/bin:${path.join(os.homedir(), '.local', 'bin')}</string>
+        <string>${envPath}</string>
     </dict>
 </dict>
 </plist>
@@ -90,12 +100,16 @@ function installLaunchd() {
     return { installed: false, message: 'launchd is macOS only.' };
   }
 
+  const binPath = resolveZcleanBin();
+  if (!binPath) {
+    return { installed: false, message: `Local zclean executable not found. ${LOCAL_BIN_HINT}` };
+  }
+
   // Ensure LaunchAgents directory exists
   if (!fs.existsSync(PLIST_DIR)) {
     fs.mkdirSync(PLIST_DIR, { recursive: true });
   }
 
-  const binPath = resolveZcleanBin();
   const plist = generatePlist(binPath);
 
   // Unload existing if present
@@ -163,4 +177,19 @@ function removeLaunchd() {
   };
 }
 
-module.exports = { installLaunchd, removeLaunchd, PLIST_PATH };
+function escapeXml(value) {
+  return String(value)
+    .replace(/&/g, '&amp;')
+    .replace(/</g, '&lt;')
+    .replace(/>/g, '&gt;')
+    .replace(/"/g, '&quot;')
+    .replace(/'/g, '&apos;');
+}
+
+module.exports = {
+  installLaunchd,
+  removeLaunchd,
+  generatePlist,
+  resolveZcleanBin,
+  PLIST_PATH,
+};

package/src/installer/systemd.js

@@ -4,46 +4,24 @@ const fs = require('fs');
 const path = require('path');
 const os = require('os');
 const { execSync } = require('child_process');
+const { LOCAL_BIN_HINT, quoteSystemdArg, resolveZcleanBin } = require('./bin-path');
 
 const SYSTEMD_USER_DIR = path.join(os.homedir(), '.config', 'systemd', 'user');
 const SERVICE_NAME = 'zclean';
 const SERVICE_PATH = path.join(SYSTEMD_USER_DIR, `${SERVICE_NAME}.service`);
 const TIMER_PATH = path.join(SYSTEMD_USER_DIR, `${SERVICE_NAME}.timer`);
 
-/**
- * Resolve the full path to the zclean binary.
- */
-function resolveZcleanBin() {
-  try {
-    const npmBin = execSync('npm bin -g', { encoding: 'utf-8', timeout: 5000 }).trim();
-    const globalPath = path.join(npmBin, 'zclean');
-    if (fs.existsSync(globalPath)) return globalPath;
-  } catch { /* ignore */ }
-
-  const candidates = [
-    path.join(os.homedir(), '.local', 'bin', 'zclean'),
-    '/usr/local/bin/zclean',
-    path.join(os.homedir(), '.local', 'share', 'npm', 'bin', 'zclean'),
-  ];
-
-  for (const candidate of candidates) {
-    if (fs.existsSync(candidate)) return candidate;
-  }
-
-  return path.join(os.homedir(), '.local', 'bin', 'zclean');
-}
-
 /**
  * Generate the systemd service unit file.
  */
 function generateService(binPath) {
   return `[Unit]
 Description=zclean - AI coding tool zombie process cleaner
-Documentation=https://github.com/whynowlab/zclean
+Documentation=https://github.com/TheStack-ai/zclean
 
 [Service]
 Type=oneshot
-ExecStart=${binPath} --yes
+ExecStart=${quoteSystemdArg(binPath)} --yes
 Environment=PATH=/usr/local/bin:/usr/bin:/bin:%h/.local/bin
 StandardOutput=append:%h/.zclean/systemd.log
 StandardError=append:%h/.zclean/systemd.log
@@ -56,7 +34,7 @@ StandardError=append:%h/.zclean/systemd.log
 function generateTimer() {
   return `[Unit]
 Description=Run zclean hourly
-Documentation=https://github.com/whynowlab/zclean
+Documentation=https://github.com/TheStack-ai/zclean
 
 [Timer]
 OnCalendar=hourly
@@ -78,13 +56,16 @@ function installSystemd() {
     return { installed: false, message: 'systemd is Linux only.' };
   }
 
+  const binPath = resolveZcleanBin();
+  if (!binPath) {
+    return { installed: false, message: `Local zclean executable not found. ${LOCAL_BIN_HINT}` };
+  }
+
   // Ensure systemd user directory exists
   if (!fs.existsSync(SYSTEMD_USER_DIR)) {
     fs.mkdirSync(SYSTEMD_USER_DIR, { recursive: true });
   }
 
-  const binPath = resolveZcleanBin();
-
   // Write service and timer files
   fs.writeFileSync(SERVICE_PATH, generateService(binPath), 'utf-8');
   fs.writeFileSync(TIMER_PATH, generateTimer(), 'utf-8');
@@ -159,4 +140,12 @@ function removeSystemd() {
   };
 }
 
-module.exports = { installSystemd, removeSystemd, SERVICE_PATH, TIMER_PATH };
+module.exports = {
+  installSystemd,
+  removeSystemd,
+  generateService,
+  generateTimer,
+  resolveZcleanBin,
+  SERVICE_PATH,
+  TIMER_PATH,
+};

package/src/installer/taskscheduler.js

@@ -1,31 +1,25 @@
 'use strict';
 
-const { execSync } = require('child_process');
-const path = require('path');
+const { execFileSync } = require('child_process');
 const os = require('os');
-const fs = require('fs');
+const { LOCAL_BIN_HINT, resolveZcleanBin } = require('./bin-path');
 
 const TASK_NAME = 'zclean-hourly';
 
-/**
- * Resolve the full path to the zclean binary on Windows.
- */
-function resolveZcleanBin() {
-  // Check npm global
-  try {
-    const npmPrefix = execSync('npm prefix -g', { encoding: 'utf-8', timeout: 5000 }).trim();
-    const candidate = path.join(npmPrefix, 'zclean.cmd');
-    if (fs.existsSync(candidate)) return candidate;
-    const candidate2 = path.join(npmPrefix, 'node_modules', '.bin', 'zclean.cmd');
-    if (fs.existsSync(candidate2)) return candidate2;
-  } catch { /* ignore */ }
-
-  // Check AppData local
-  const appData = process.env.APPDATA || path.join(os.homedir(), 'AppData', 'Roaming');
-  const npmGlobal = path.join(appData, 'npm', 'zclean.cmd');
-  if (fs.existsSync(npmGlobal)) return npmGlobal;
+function buildCreateTaskArgs(binPath) {
+  return [
+    '/create',
+    '/TN', TASK_NAME,
+    '/SC', 'HOURLY',
+    '/TR', formatTaskRunCommand(binPath),
+    '/F',
+  ];
+}
 
-  return 'npx zclean';
+function formatTaskRunCommand(binPath) {
+  const text = String(binPath);
+  const command = /\s/.test(text) ? `"${text.replace(/"/g, '\\"')}"` : text;
+  return `${command} --yes`;
 }
 
 /**
@@ -41,22 +35,14 @@ function installTaskScheduler() {
   }
 
   const binPath = resolveZcleanBin();
+  if (!binPath) {
+    return { installed: false, message: `Local zclean executable not found. ${LOCAL_BIN_HINT}` };
+  }
 
-  // Build schtasks command
-  // /SC HOURLY — run every hour
-  // /TN — task name
-  // /TR — task to run
-  // /F — force overwrite if exists
-  const command = [
-    'schtasks', '/create',
-    '/TN', `"${TASK_NAME}"`,
-    '/SC', 'HOURLY',
-    '/TR', `"${binPath} --yes"`,
-    '/F',
-  ].join(' ');
+  const args = buildCreateTaskArgs(binPath);
 
   try {
-    execSync(command, { encoding: 'utf-8', timeout: 10000 });
+    execFileSync('schtasks', args, { encoding: 'utf-8', timeout: 10000 });
     return {
       installed: true,
       message: `Task Scheduler task created: ${TASK_NAME} (hourly)`,
@@ -80,7 +66,7 @@ function removeTaskScheduler() {
   }
 
   try {
-    execSync(`schtasks /delete /TN "${TASK_NAME}" /F`, {
+    execFileSync('schtasks', ['/delete', '/TN', TASK_NAME, '/F'], {
       encoding: 'utf-8',
       timeout: 10000,
     });
@@ -99,4 +85,11 @@ function removeTaskScheduler() {
   }
 }
 
-module.exports = { installTaskScheduler, removeTaskScheduler, TASK_NAME };
+module.exports = {
+  installTaskScheduler,
+  removeTaskScheduler,
+  resolveZcleanBin,
+  buildCreateTaskArgs,
+  formatTaskRunCommand,
+  TASK_NAME,
+};

package/src/killer.js

@@ -3,6 +3,7 @@
 const { execSync } = require('child_process');
 const os = require('os');
 const { appendLog } = require('./config');
+const { normalizePid, readWindowsProcess, windowsProcessExists } = require('./windows-processes');
 
 const platform = os.platform();
 
@@ -24,9 +25,17 @@ const platform = os.platform();
  */
 function killZombies(zombies, config) {
   const timeout = (config.sigterm_timeout || 10) * 1000;
-  const results = { killed: [], failed: [], skipped: [] };
+  const limit = config.maxKillBatch || 20;
+  const results = { killed: [], failed: [], skipped: [], warning: null };
 
-  for (const proc of zombies) {
+  // Rate limit: only kill up to maxKillBatch processes
+  let toKill = zombies;
+  if (zombies.length > limit) {
+    toKill = zombies.slice(0, limit);
+    results.warning = `Found ${zombies.length} zombies, killing ${limit}. Run again for remaining.`;
+  }
+
+  for (const proc of toKill) {
     // Re-verify before killing
     const verification = verifyProcess(proc);
     if (!verification.valid) {
@@ -73,6 +82,7 @@ function killZombies(zombies, config) {
     killed: results.killed.length,
     failed: results.failed.length,
     skipped: results.skipped.length,
+    limited: zombies.length > limit,
     totalMemFreed: results.killed.reduce((sum, p) => sum + p.mem, 0),
   });
 
@@ -83,17 +93,18 @@ function killZombies(zombies, config) {
  * Re-verify a process before killing it.
  * Ensures we don't kill a recycled PID or wrong process.
  */
-function verifyProcess(proc) {
-  if (platform === 'win32') {
-    return verifyProcessWindows(proc);
+function verifyProcess(proc, options = {}) {
+  const runtime = runtimeOptions(options);
+  if (runtime.platform === 'win32') {
+    return verifyProcessWindows(proc, runtime);
   }
-  return verifyProcessUnix(proc);
+  return verifyProcessUnix(proc, runtime);
 }
 
-function verifyProcessUnix(proc) {
+function verifyProcessUnix(proc, runtime = runtimeOptions()) {
   try {
     // Check if PID still exists and get its command line
-    const cmd = execSync(`ps -o command= -p ${proc.pid}`, {
+    const cmd = runtime.execSync(`ps -o command= -p ${proc.pid}`, {
       encoding: 'utf-8',
       timeout: 5000,
     }).trim();
@@ -113,7 +124,7 @@ function verifyProcessUnix(proc) {
     // Verify start time if available
     if (proc.startTime) {
       try {
-        const lstart = execSync(`ps -o lstart= -p ${proc.pid}`, {
+        const lstart = runtime.execSync(`ps -o lstart= -p ${proc.pid}`, {
           encoding: 'utf-8',
           timeout: 5000,
         }).trim();
@@ -132,30 +143,29 @@ function verifyProcessUnix(proc) {
   }
 }
 
-function verifyProcessWindows(proc) {
-  try {
-    const output = execSync(
-      `wmic process where ProcessId=${proc.pid} get CommandLine /value`,
-      { encoding: 'utf-8', timeout: 5000 }
-    ).trim();
+function verifyProcessWindows(proc, runtime = runtimeOptions({ platform: 'win32' })) {
+  const current = readWindowsProcess(proc.pid, runtime);
+  if (!current) {
+    return { valid: false, reason: 'process-gone' };
+  }
 
-    const match = output.match(/CommandLine=(.+)/);
-    if (!match) {
-      return { valid: false, reason: 'process-gone' };
-    }
+  const currentCmd = String(current.cmd || '').trim();
+  const scanPrefix = proc.cmd.substring(0, 50);
+  const currentPrefix = currentCmd.substring(0, 50);
 
-    const currentCmd = match[1].trim();
-    const scanPrefix = proc.cmd.substring(0, 50);
-    const currentPrefix = currentCmd.substring(0, 50);
+  if (scanPrefix !== currentPrefix) {
+    return { valid: false, reason: 'cmd-mismatch' };
+  }
 
-    if (scanPrefix !== currentPrefix) {
-      return { valid: false, reason: 'cmd-mismatch' };
-    }
+  if (proc.startTime && current.startTime && current.startTime !== proc.startTime) {
+    return { valid: false, reason: 'start-time-mismatch' };
+  }
 
-    return { valid: true, reason: 'verified' };
-  } catch {
-    return { valid: false, reason: 'process-gone' };
+  if (proc.startTime && !current.startTime) {
+    return { valid: false, reason: 'start-time-unverified' };
   }
+
+  return { valid: true, reason: 'verified' };
 }
 
 /**
@@ -164,14 +174,15 @@ function verifyProcessWindows(proc) {
  * macOS/Linux: SIGTERM → wait → SIGKILL
  * Windows: taskkill → wait → taskkill /F
  */
-function killProcess(pid, timeoutMs) {
-  if (platform === 'win32') {
-    return killProcessWindows(pid, timeoutMs);
+function killProcess(pid, timeoutMs, options = {}) {
+  const runtime = runtimeOptions(options);
+  if (runtime.platform === 'win32') {
+    return killProcessWindows(pid, timeoutMs, runtime);
   }
-  return killProcessUnix(pid, timeoutMs);
+  return killProcessUnix(pid, timeoutMs, runtime);
 }
 
-function killProcessUnix(pid, timeoutMs) {
+function killProcessUnix(pid, timeoutMs, runtime = runtimeOptions()) {
   try {
     // Send SIGTERM
     process.kill(pid, 'SIGTERM');
@@ -189,11 +200,8 @@ function killProcessUnix(pid, timeoutMs) {
     try {
       // process.kill(pid, 0) throws if process doesn't exist
       process.kill(pid, 0);
-      // Still alive — busy wait in small increments
-      const waitUntil = Date.now() + 500;
-      while (Date.now() < waitUntil) {
-        // Spin wait — we can't use setTimeout synchronously
-      }
+      // Still alive — blocking sleep to avoid CPU spin
+      try { runtime.execSync('sleep 0.5', { timeout: 2000 }); } catch { /* ignore */ }
     } catch {
       // Process is gone
       return { success: true, method: 'sigterm' };
@@ -212,37 +220,45 @@ function killProcessUnix(pid, timeoutMs) {
   }
 }
 
-function killProcessWindows(pid, timeoutMs) {
+function killProcessWindows(pid, timeoutMs, runtime = runtimeOptions({ platform: 'win32' })) {
+  const safePid = normalizePid(pid);
+  if (!safePid) {
+    return { success: false, error: `Invalid PID: ${pid}` };
+  }
+
   try {
     // Graceful kill
-    execSync(`taskkill /PID ${pid}`, { encoding: 'utf-8', timeout: 5000 });
+    runtime.execSync(`taskkill /PID ${safePid}`, { encoding: 'utf-8', timeout: 5000 });
   } catch {
     // Might fail — try force kill directly
   }
 
   // Wait
-  const deadline = Date.now() + timeoutMs;
-  while (Date.now() < deadline) {
-    try {
-      execSync(`wmic process where ProcessId=${pid} get ProcessId /value`, {
-        encoding: 'utf-8',
-        timeout: 3000,
-      });
-      // Still alive — wait
-      const waitUntil = Date.now() + 500;
-      while (Date.now() < waitUntil) { /* spin */ }
-    } catch {
+  const deadline = runtime.now() + timeoutMs;
+  while (runtime.now() < deadline) {
+    const exists = windowsProcessExists(safePid, runtime);
+    if (exists === false) {
       return { success: true, method: 'taskkill' };
     }
+    if (exists === null) break;
+    try { runtime.execSync('timeout /T 1 /NOBREAK >nul', { timeout: 3000 }); } catch { /* ignore */ }
   }
 
   // Force kill
   try {
-    execSync(`taskkill /F /PID ${pid}`, { encoding: 'utf-8', timeout: 5000 });
+    runtime.execSync(`taskkill /F /PID ${safePid}`, { encoding: 'utf-8', timeout: 5000 });
     return { success: true, method: 'taskkill-force' };
   } catch (err) {
     return { success: false, error: `Force kill failed: ${err.message}` };
   }
 }
 
+function runtimeOptions(options = {}) {
+  return {
+    execSync: options.execSync || execSync,
+    platform: options.platform || platform,
+    now: typeof options.now === 'function' ? options.now : () => Date.now(),
+  };
+}
+
 module.exports = { killZombies, verifyProcess, killProcess };