@goodandready/dsh-cron 0.3.25 → 0.3.26

package/lib/runner-external.js

@@ -1,352 +1 @@
-import { logStreamer } from './log-streamer.js';
-import { logger } from './logger.js';
-import { bestEffort } from './best-effort.js';
-import {
-  buildInvocation,
-} from './runtimes.js';
-
-/**
- * Helper to detect context window overflow errors in persistent sessions (#145).
- */
-export function isContextOverflowError(err) {
-  const msg = String(err?.message || err || '').toLowerCase();
-  return msg.includes('context length') ||
-         msg.includes('context window') ||
-         msg.includes('maximum context') ||
-         msg.includes('too many tokens') ||
-         msg.includes('prompt too long') ||
-         msg.includes('token limit') ||
-         msg.includes('context_length_exceeded') ||
-         msg.includes('string_above_max_length');
-}
-
-/**
- * Cross-platform process tree killer (#145).
- * On Windows, calls `taskkill /pid <pid> /T /F` to terminate the entire process hierarchy.
- */
-export function terminateProcessTree(child, sig = 'SIGTERM', { isPosix = process.platform !== 'win32', execFn } = {}) {
-  if (!child || child.killed) return;
-  bestEffort('terminate-process-tree', () => {
-    if (isPosix && child.pid) {
-      bestEffort('kill-posix-pid', () => process.kill(-child.pid, sig));
-    } else if (child.pid) {
-      const runner = execFn || ((cmd) => {
-        bestEffort('exec-taskkill-fn', () => {
-          import('node:child_process').then(({ exec }) => {
-            exec(cmd, { windowsHide: true }, () => {});
-          }).catch(() => {});
-        });
-      });
-      bestEffort('exec-taskkill', () => runner(`taskkill /pid ${child.pid} /T /F`));
-      bestEffort('child-kill', () => child.kill(sig));
-    }
-  });
-}
-
-/**
- * Helper to test if an error code or status is transient and eligible for retry (#134).
- */
-export function isTransientError(errOrStatus) {
-  if (typeof errOrStatus === 'number') {
-    return errOrStatus === 429 || errOrStatus === 502 || errOrStatus === 503 || errOrStatus === 504;
-  }
-  const str = String(errOrStatus?.message || errOrStatus || '').toLowerCase();
-  return str.includes('429') || str.includes('too many requests') ||
-         str.includes('502') || str.includes('bad gateway') ||
-         str.includes('503') || str.includes('service unavailable') ||
-         str.includes('504') || str.includes('gateway timeout') ||
-         str.includes('econnreset') || str.includes('etimedout');
-}
-
-/** HTTP trigger runtime (#7) with transient retry (#134). */
-export async function runHttp(task, request, signal) {
-  const streamRunId = `run_${Date.now()}`;
-  logStreamer.startStream(task.id, streamRunId);
-  logStreamer.appendLog(task.id, `> ${request.method} ${request.url}
-`, 'stdout');
-  let attempts = 0;
-  const maxAttempts = 3;
-  while (attempts < maxAttempts) {
-    attempts++;
-    try {
-      const res = await fetch(request.url, {
-        method: request.method,
-        headers: request.headers,
-        body: request.body,
-        signal,
-      });
-      const text = await res.text().catch(() => '');
-      const summary = `${request.method} ${request.url} -> ${res.status} ${res.statusText || ''}`.trim();
-      if (!res.ok) {
-        const err = new Error(`${summary}\n${String(text).slice(0, 500)}`);
-        if (isTransientError(res.status) && attempts < maxAttempts && !signal?.aborted) {
-          logger.warn(`[dsh-cron] HTTP request returned ${res.status}, retrying attempt ${attempts + 1}/${maxAttempts}...`);
-          await new Promise((r) => setTimeout(r, attempts * 1000));
-          continue;
-        }
-        throw err;
-      }
-      return {
-        output: `${summary}\n${String(text).trim().slice(0, 4000)}`.trim(),
-        usage: { inputTokens: 0, outputTokens: 0, cacheReadTokens: 0 },
-        costUsd: 0,
-      };
-    } catch (err) {
-      if (isTransientError(err) && attempts < maxAttempts && !signal?.aborted) {
-        logger.warn(`[dsh-cron] HTTP request failed (${err.message}), retrying attempt ${attempts + 1}/${maxAttempts}...`);
-        await new Promise((r) => setTimeout(r, attempts * 1000));
-        continue;
-      }
-      throw err;
-    }
-  }
-}
-
-/**
- * #9 reuse-first path: when the task names a dsh-remote-workspace profile,
- * execute through that plugin's `remoteSsh` service so host settings and
- * credentials stay owned by it (we only reference the profile id).
- * Returns null when the service or the profile is unavailable so the caller
- * can fall back to a direct ssh invocation.
- */
-export async function runViaRemoteWorkspace(task, signal, ctx) {
-  if (!task.sshProfileId || !ctx || typeof ctx.get !== 'function') return null;
-  let svc = null;
-  svc = bestEffort('get-remoteSsh', () => ctx.get('remoteSsh'));
-  if (!svc || typeof svc.exec !== 'function') return null;
-
-  let profile = null;
-  profile = bestEffort('get-remoteSsh-profile', () => {
-    const remoteProfilesSvc = ctx.get('remoteProfiles');
-    if (remoteProfilesSvc && typeof remoteProfilesSvc.list === 'function') {
-      const list = remoteProfilesSvc.list();
-      if (Array.isArray(list)) {
-        const found = list.find((p) => p && p.id === task.sshProfileId);
-        if (found) return found;
-      }
-    }
-    const settings = ctx.get('settings');
-    if (settings) {
-      if (typeof settings.describe === 'function') {
-        const desc = settings.describe();
-        const entry = Array.isArray(desc) ? desc.find((r) => r && r.ns === 'dsh-remote-workspace') : null;
-        const snap = entry ? entry.value : null;
-        const profiles = snap && Array.isArray(snap.profiles) ? snap.profiles : [];
-        const found = profiles.find((p) => p && p.id === task.sshProfileId);
-        if (found) return found;
-      }
-      if (typeof settings.get === 'function') {
-        const snap = settings.get('dsh-remote-workspace');
-        const profiles = snap && Array.isArray(snap.profiles) ? snap.profiles : [];
-        return profiles.find((p) => p && p.id === task.sshProfileId) || null;
-      }
-    }
-    return null;
-  });
-  if (!profile) {
-    throw new Error(`remote-workspace profile "${task.sshProfileId}" was not found — check dsh-remote-workspace settings, or use sshTarget instead`);
-  }
-  const res = await svc.exec(profile, String(task.prompt || 'true'), task.cwd || profile.remoteWorkspace || undefined);
-  const output = [res && res.stdout, res && res.stderr].filter((x) => x && String(x).trim()).join('\n').trim();
-  const code = res && typeof res.code === 'number' ? res.code : 0;
-  if (code !== 0) {
-    throw new Error(`Remote command exited with code ${code}\n${output}`.slice(0, 4000));
-  }
-  return {
-    output: output || 'Remote command completed with code 0',
-    usage: { inputTokens: 0, outputTokens: 0, cacheReadTokens: 0 },
-    costUsd: 0,
-  };
-}
-
-/** Non-LLM runtimes: shell, Node.js, Python, HTTP, SSH, Docker (#4 #5 #7 #8 #9). */
-export async function runExternal(task, runtime, signal, execOptions = {}, { ctx = null, resolveCwdFn = null } = {}) {
-  if (runtime === 'ssh' && task.sshProfileId) {
-    const viaService = await runViaRemoteWorkspace(task, signal, ctx);
-    if (viaService) return viaService;
-    if (!task.sshTarget) {
-      throw new Error('SSH task needs either a working dsh-remote-workspace profile (sshProfileId) or an sshTarget');
-    }
-  }
-  const cwd = resolveCwdFn ? resolveCwdFn(task) : (task.cwd || process.cwd());
-  const invocation = buildInvocation({ ...task, type: runtime }, cwd);
-  if (invocation.http) return runHttp(task, invocation.http, signal);
-
-  const { spawn, exec } = await import('node:child_process');
-  return new Promise((resolve, reject) => {
-    let child = null;
-    let settled = false;
-    let timedOut = false;
-    let stdout = '';
-    let stderr = '';
-    let truncated = false;
-    // Issue #393: maxLogBytesPerRun cap (default 5MB)
-    const maxLogBytes = Number(task.maxLogBytesPerRun) > 0 ? Number(task.maxLogBytesPerRun) : 5 * 1024 * 1024;
-    const isPosix = process.platform !== 'win32';
-
-    // Issue #393: Execution timeout guardrail (default 15 minutes = 900,000ms, or task.executionTimeoutMs / timeoutSeconds)
-    const effectiveTimeoutMs = Number(task.executionTimeoutMs) > 0
-      ? Number(task.executionTimeoutMs)
-      : (Number(task.timeoutSeconds) > 0 ? Number(task.timeoutSeconds) * 1000 : 15 * 60 * 1000);
-
-    let timeoutTimer = null;
-    let forceKillTimer = null;
-
-    const killProcessTree = (sig = 'SIGTERM') => {
-      terminateProcessTree(child, sig, {
-        isPosix,
-        execFn: (cmd) => {
-          bestEffort('exec-cmd', () => exec(cmd, { windowsHide: true }, () => {}));
-        }
-      });
-    };
-
-    const cleanupTimers = () => {
-      if (timeoutTimer) { clearTimeout(timeoutTimer); timeoutTimer = null; }
-      if (forceKillTimer) { clearTimeout(forceKillTimer); forceKillTimer = null; }
-    };
-
-    if (effectiveTimeoutMs > 0) {
-      timeoutTimer = setTimeout(() => {
-        if (settled) return;
-        timedOut = true;
-        logger.warn(`[dsh-cron] task "${task.title || task.id}" timed out after ${effectiveTimeoutMs}ms, sending SIGTERM`);
-        killProcessTree('SIGTERM');
-        forceKillTimer = setTimeout(() => {
-          if (!settled) {
-            logger.warn(`[dsh-cron] task "${task.title || task.id}" force killing with SIGKILL`);
-            killProcessTree('SIGKILL');
-          }
-        }, 3000);
-        if (typeof forceKillTimer.unref === 'function') forceKillTimer.unref();
-      }, effectiveTimeoutMs);
-      if (typeof timeoutTimer.unref === 'function') timeoutTimer.unref();
-    }
-
-    const abortHandler = () => {
-      cleanupTimers();
-      killProcessTree('SIGTERM');
-      setTimeout(() => killProcessTree('SIGKILL'), 300);
-    };
-
-    if (signal) {
-      if (signal.aborted) {
-        cleanupTimers();
-        return reject(signal.reason || new Error('Command aborted'));
-      }
-      signal.addEventListener('abort', abortHandler, { once: true });
-    }
-
-    const runEnv = { ...invocation.env };
-    if (execOptions?.prevOutput !== undefined) {
-      runEnv.DSH_PREV_OUTPUT = String(execOptions.prevOutput);
-    }
-    const streamRunId = execOptions?.runId || `run_${Date.now()}`;
-    logStreamer.startStream(task.id, streamRunId);
-    const options = {
-      cwd,
-      env: runEnv,
-      detached: isPosix,
-      stdio: ['ignore', 'pipe', 'pipe'],
-    };
-
-    if (invocation.file) {
-      child = spawn(invocation.file, invocation.args || [], options);
-    } else {
-      let command = invocation.shellCommand;
-      if (isPosix && Number(task.maxMemoryMb) > 0) {
-        command = `ulimit -v ${Number(task.maxMemoryMb) * 1024} 2>/dev/null || true; ${command}`;
-      }
-      const shellPath = isPosix ? (process.env.SHELL || '/bin/bash') : (process.env.ComSpec || 'cmd.exe');
-      const shellArgs = isPosix ? ['-c', command] : ['/d', '/s', '/c', command];
-      child = spawn(shellPath, shellArgs, options);
-    }
-
-    child.stdout.on('data', (chunk) => {
-      const remaining = maxLogBytes - (stdout.length + stderr.length);
-      const text = chunk.toString('utf-8');
-      if (remaining > 0) {
-        if (text.length <= remaining) {
-          stdout += text;
-          if (!truncated) logStreamer.appendLog(task.id, text, 'stdout');
-        } else {
-          stdout += text.slice(0, remaining);
-          if (!truncated) {
-            truncated = true;
-            const note = `\n[TRUNCATED: log output exceeded maxLogBytesPerRun (${Math.round(maxLogBytes / 1024 / 1024)}MB)]`;
-            stdout += note;
-            logStreamer.appendLog(task.id, text.slice(0, remaining) + note, 'stdout');
-          }
-        }
-      } else if (!truncated) {
-        truncated = true;
-        const note = `\n[TRUNCATED: log output exceeded maxLogBytesPerRun (${Math.round(maxLogBytes / 1024 / 1024)}MB)]`;
-        stdout += note;
-        logStreamer.appendLog(task.id, note, 'stdout');
-      }
-    });
-
-    child.stderr.on('data', (chunk) => {
-      const remaining = maxLogBytes - (stdout.length + stderr.length);
-      const text = chunk.toString('utf-8');
-      if (remaining > 0) {
-        if (text.length <= remaining) {
-          stderr += text;
-          if (!truncated) logStreamer.appendLog(task.id, text, 'stderr');
-        } else {
-          stderr += text.slice(0, remaining);
-          if (!truncated) {
-            truncated = true;
-            const note = `\n[TRUNCATED: log output exceeded maxLogBytesPerRun (${Math.round(maxLogBytes / 1024 / 1024)}MB)]`;
-            stderr += note;
-            logStreamer.appendLog(task.id, text.slice(0, remaining) + note, 'stderr');
-          }
-        }
-      } else if (!truncated) {
-        truncated = true;
-        const note = `\n[TRUNCATED: log output exceeded maxLogBytesPerRun (${Math.round(maxLogBytes / 1024 / 1024)}MB)]`;
-        stderr += note;
-        logStreamer.appendLog(task.id, note, 'stderr');
-      }
-    });
-
-    child.on('error', (err) => {
-      if (settled) return;
-      settled = true;
-      cleanupTimers();
-      if (signal) signal.removeEventListener('abort', abortHandler);
-      logStreamer.completeStream(task.id, { status: 'error', error: err.message, exitCode: 1 });
-      reject(err);
-    });
-
-    child.on('close', (code, sig) => {
-      if (settled) return;
-      settled = true;
-      cleanupTimers();
-      if (signal) signal.removeEventListener('abort', abortHandler);
-
-      if (timedOut) {
-        logStreamer.completeStream(task.id, { status: 'timeout', error: `Execution timed out after ${effectiveTimeoutMs}ms`, exitCode: 124 });
-        return reject(new Error(`Execution timed out after ${effectiveTimeoutMs}ms (SIGTERM/SIGKILL sent)`));
-      }
-
-      if (signal && signal.aborted) {
-        return reject(signal.reason || new Error('Command aborted'));
-      }
-
-      if (code !== 0 && code !== null) {
-        const detail = String(stderr || '').trim();
-        const msg = `${runtime} task exited with code ${code}`;
-        return reject(new Error(detail ? `${msg}\n${detail}` : msg));
-      }
-
-      const out = (stdout || stderr || '').trim();
-      resolve({
-        output: out || `${runtime} task completed with code 0`,
-        usage: { inputTokens: 0, outputTokens: 0, cacheReadTokens: 0 },
-        costUsd: 0,
-      });
-    });
-  });
-}
-
+export * from './runtimes/runner-external.js';

package/lib/runner-worktree.js

@@ -1,90 +1 @@
-import { logger } from './logger.js';
-import { bestEffort } from './best-effort.js';
-
-import fs from 'node:fs';
-
-/**
- * Resolve the working directory for a task: explicit cwd, a bound
- * workspace id resolved through the harness, or the process cwd (#31).
- */
-export function resolveCwd(task, ctx = null) {
-  if (task.cwd) return String(task.cwd);
-  if (task.workspaceId) {
-    const rawId = String(task.workspaceId).trim();
-    if (ctx) {
-      const resolved = bestEffort('resolve-workspace-path', () => {
-        // Issue #363 / GH #12: host workspace service is 'workspaceRegistry' in DeepSeek Harness
-        const registry =
-          (typeof ctx.get === 'function' ? ctx.get('workspaceRegistry') : null) ||
-          ctx.workspaceRegistry ||
-          (typeof ctx.get === 'function' ? ctx.get('workspaces') : null) ||
-          ctx.workspaces;
-
-        if (registry) {
-          // 1. Direct get(id) lookup on WorkspaceRegistry
-          if (typeof registry.get === 'function') {
-            const ws = registry.get(rawId);
-            if (ws && ws.path) return String(ws.path);
-          }
-          // 2. List lookup if ID, title, or Path was provided ("Workspace id or path")
-          if (typeof registry.list === 'function') {
-            const list = registry.list();
-            if (Array.isArray(list)) {
-              const matched = list.find((w) => w && (w.id === rawId || w.path === rawId || w.title === rawId));
-              if (matched && matched.path) return String(matched.path);
-            }
-          }
-        }
-        return null;
-      });
-      if (resolved) return resolved;
-    }
-
-    // 3. Fallback: if task.workspaceId directly points to an existing directory path on disk
-    try {
-      if (fs.existsSync(rawId) && fs.statSync(rawId).isDirectory()) {
-        return rawId;
-      }
-    } catch (_fsErr) {
-      // ignore filesystem stat error
-    }
-
-    // Issue #231: fail-closed if workspaceId was specified but cannot be resolved
-    throw new Error(`Workspace "${task.workspaceId}" requested by task could not be resolved`);
-  }
-  return process.cwd();
-}
-
-/**
- * Create an isolated git worktree for a run when task.worktree is requested (#29).
- * Returns the directory path of the worktree.
- */
-export async function createTaskWorktree(cwd, task) {
-  const { execFile } = await import('node:child_process');
-  const { randomUUID } = await import('node:crypto');
-  const branch = `cron-${task.id}-${randomUUID().slice(0, 8)}`;
-  const wtPath = `${cwd}/.worktrees/${branch}`;
-  return new Promise((resolve, reject) => {
-    execFile('git', ['-C', cwd, 'worktree', 'add', '-b', branch, wtPath, 'HEAD'], (err) => {
-      if (err) return reject(new Error(`Failed to create worktree: ${err.message}`));
-      resolve(wtPath);
-    });
-  });
-}
-
-/**
- * Clean up the isolated worktree after execution unless keepWorktree is set (#29).
- * Uses best-effort removal without forcing, followed by git worktree prune.
- */
-export async function removeTaskWorktree(cwd, wtPath) {
-  const { execFile } = await import('node:child_process');
-  await new Promise((resolve) => {
-    execFile('git', ['-C', cwd, 'worktree', 'remove', wtPath], { maxBuffer: 4 * 1024 * 1024 }, (err, stdout, stderr) => {
-      if (err) {
-        logger.warn(`[dsh-cron] task worktree kept (not removable without force): ${wtPath} — ${String(stderr || err.message).trim()}`);
-      }
-      execFile('git', ['-C', cwd, 'worktree', 'prune'], () => resolve());
-    });
-  });
-}
-
+export * from './runtimes/runner-worktree.js';