@goodandready/dsh-cron 0.2.18 → 0.2.20

package/lib/runner.js

@@ -1,62 +1,31 @@
-/**
- * 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;
-  try {
-    if (isPosix && child.pid) {
-      try { process.kill(-child.pid, sig); } catch {}
-    } else if (child.pid) {
-      const runner = execFn || ((cmd) => {
-        try {
-          import('node:child_process').then(({ exec }) => {
-            exec(cmd, { windowsHide: true }, () => {});
-          }).catch(() => {});
-        } catch {}
-      });
-      try { runner(`taskkill /pid ${child.pid} /T /F`); } catch {}
-      try { child.kill(sig); } catch {}
-    }
-  } catch {}
-}
-
-/**
- * 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');
-}
-
+import { bestEffort } from './best-effort.js';
 import { estimateTokenCost } from './integrations.js';
 import {
   EXTERNAL_RUNTIMES,
   normalizeTaskType,
-  buildInvocation,
 } from './runtimes.js';
+import {
+  isContextOverflowError,
+  terminateProcessTree,
+  isTransientError,
+  runHttp,
+  runViaRemoteWorkspace,
+  runExternal,
+} from './runner-external.js';
+import {
+  resolveCwd,
+  createTaskWorktree,
+  removeTaskWorktree,
+} from './runner-worktree.js';
+
+export {
+  isContextOverflowError,
+  terminateProcessTree,
+  isTransientError,
+  resolveCwd,
+  createTaskWorktree,
+  removeTaskWorktree,
+};
 
 /**
  * Runner executing scheduled tasks in DeepSeek Harness sessions.
@@ -138,235 +107,36 @@ export class SessionRunner {
     }
   }
 
-  /**
-   * Resolve the working directory for a task: explicit cwd, a bound
-   * workspace id resolved through the harness, or the process cwd (#31).
-   */
+  /** Resolve working directory for task via runner-worktree */
   resolveCwd(task) {
-    if (task.cwd) return String(task.cwd);
-    if (task.workspaceId && this.ctx && typeof this.ctx.get === 'function') {
-      try {
-        const workspaces = this.ctx.get('workspaces');
-        const ws = workspaces && (typeof workspaces.get === 'function'
-          ? workspaces.get(task.workspaceId)
-          : (workspaces[task.workspaceId] || null));
-        const resolved = ws && (ws.path || ws.cwd || ws.root || ws.dir);
-        if (resolved) return String(resolved);
-      } catch {}
-      return String(task.workspaceId);
-    }
-    return process.cwd();
+    return resolveCwd(task, this.ctx);
   }
 
-  /** Create an isolated git worktree for a code-modifying task (#29). */
+  /** Create isolated worktree via runner-worktree */
   async createTaskWorktree(cwd, task) {
-    const { execFile } = await import('node:child_process');
-    const path = await import('node:path');
-    const wtPath = path.join(cwd, '.dsh-cron-worktrees', `${task.id}-${Date.now()}`);
-    await new Promise((resolve, reject) => {
-      execFile('git', ['-C', cwd, 'worktree', 'add', '--detach', wtPath, 'HEAD'], { maxBuffer: 4 * 1024 * 1024 }, (err, stdout, stderr) => {
-        if (err) reject(new Error(String(stderr || err.message).trim()));
-        else resolve(stdout);
-      });
-    });
-    return wtPath;
+    return createTaskWorktree(cwd, task);
   }
 
-  /**
-   * Remove a task worktree; never throws (best-effort cleanup).
-   * Plain removal only — no force flags anywhere (workspace rule). A dirty
-   * worktree is left in place and reported instead of being force-deleted.
-   */
+  /** Remove isolated worktree via runner-worktree */
   async 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) {
-          console.warn(`[dsh-cron] task worktree kept (not removable without force): ${wtPath} — ${String(stderr || err.message).trim()}`);
-        }
-        execFile('git', ['-C', cwd, 'worktree', 'prune'], () => resolve());
-      });
-    });
+    return removeTaskWorktree(cwd, wtPath);
   }
 
-  /** HTTP trigger runtime (#7) with transient retry (#134). */
+  /** HTTP trigger runtime via runner-external */
   async _runHttp(task, request, signal) {
-    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) {
-            console.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) {
-          console.warn(`[dsh-cron] HTTP request failed (${err.message}), retrying attempt ${attempts + 1}/${maxAttempts}...`);
-          await new Promise((r) => setTimeout(r, attempts * 1000));
-          continue;
-        }
-        throw err;
-      }
-    }
+    return runHttp(task, request, signal);
   }
 
-  /**
-   * #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.
-   */
+  /** Remote workspace execution via runner-external */
   async _runViaRemoteWorkspace(task, signal) {
-    if (!task.sshProfileId || !this.ctx || typeof this.ctx.get !== 'function') return null;
-    let svc = null;
-    try {
-      svc = this.ctx.get('remoteSsh');
-    } catch {}
-    if (!svc || typeof svc.exec !== 'function') return null;
-
-    let profile = null;
-    try {
-      const settings = this.ctx.get('settings');
-      if (settings && typeof settings.get === 'function') {
-        const snap = settings.get('dsh-remote-workspace');
-        const profiles = snap && Array.isArray(snap.profiles) ? snap.profiles : [];
-        profile = profiles.find((p) => p && p.id === task.sshProfileId) || null;
-      }
-    } catch {}
-    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,
-    };
+    return runViaRemoteWorkspace(task, signal, this.ctx);
   }
 
-  /** Non-LLM runtimes: shell, Node.js, Python, HTTP, SSH, Docker (#4 #5 #7 #8 #9). */
+  /** Non-LLM external runtimes via runner-external */
   async _runExternal(task, runtime, signal, execOptions = {}) {
-    if (runtime === 'ssh' && task.sshProfileId) {
-      const viaService = await this._runViaRemoteWorkspace(task, signal);
-      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 = this.resolveCwd(task);
-    const invocation = buildInvocation({ ...task, type: runtime }, cwd);
-    if (invocation.http) return this._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 stdout = '';
-      let stderr = '';
-      const maxBuffer = 10 * 1024 * 1024;
-      const isPosix = process.platform !== 'win32';
-
-      const killProcessTree = (sig = 'SIGTERM') => {
-        terminateProcessTree(child, sig, {
-          isPosix,
-          execFn: (cmd) => {
-            try { exec(cmd, { windowsHide: true }, () => {}); } catch {}
-          }
-        });
-      };
-
-      const abortHandler = () => {
-        killProcessTree('SIGTERM');
-        setTimeout(() => killProcessTree('SIGKILL'), 300);
-      };
-
-      if (signal) {
-        if (signal.aborted) {
-          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 options = {
-        cwd,
-        env: runEnv,
-        detached: isPosix,
-        stdio: ['ignore', 'pipe', 'pipe'],
-      };
-
-      if (invocation.file) {
-        child = spawn(invocation.file, invocation.args || [], options);
-      } else {
-        const shellPath = isPosix ? (process.env.SHELL || '/bin/bash') : (process.env.ComSpec || 'cmd.exe');
-        const shellArgs = isPosix ? ['-c', invocation.shellCommand] : ['/d', '/s', '/c', invocation.shellCommand];
-        child = spawn(shellPath, shellArgs, options);
-      }
-
-      child.stdout.on('data', (chunk) => {
-        if (stdout.length < maxBuffer) stdout += chunk;
-      });
-      child.stderr.on('data', (chunk) => {
-        if (stderr.length < maxBuffer) stderr += chunk;
-      });
-
-      child.on('error', (err) => {
-        if (settled) return;
-        settled = true;
-        if (signal) signal.removeEventListener('abort', abortHandler);
-        reject(err);
-      });
-
-      child.on('close', (code, sig) => {
-        if (settled) return;
-        settled = true;
-        if (signal) signal.removeEventListener('abort', abortHandler);
-
-        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,
-        });
-      });
+    return runExternal(task, runtime, signal, execOptions, {
+      ctx: this.ctx,
+      resolveCwdFn: (t) => this.resolveCwd(t),
     });
   }
 
@@ -438,22 +208,22 @@ export class SessionRunner {
       // Context window overflow auto-recovery in persistent sessions (#145)
       if (prep.targetSessionId && isContextOverflowError(err) && !signal?.aborted) {
         console.warn(`[dsh-cron] Persistent session "${prep.targetSessionId}" exceeded context window (${err.message}). Auto-recovering with fresh session...`);
-        try {
+        bestEffort('archive-rotated-session', () => {
           const sessions = this.ctx?.get?.('sessions');
           if (sessions && typeof sessions.archive === 'function') {
             sessions.archive(prep.targetSessionId);
           }
-        } catch {}
+        });
         const rotatedSessionId = `${prep.targetSessionId}-${Date.now().toString(36)}`;
         console.log(`[dsh-cron] Rotated persistent session "${prep.targetSessionId}" -> "${rotatedSessionId}"`);
         if (this.store) {
-          try {
+          bestEffort('update-stored-rotated-session', () => {
             const stored = this.store.get(task.id);
             if (stored) {
               stored.targetSessionId = rotatedSessionId;
               this.store.set(stored);
             }
-          } catch {}
+          });
         }
         task.targetSessionId = rotatedSessionId;
         effectiveTask.targetSessionId = rotatedSessionId;
@@ -464,20 +234,16 @@ export class SessionRunner {
       throw err;
     }
   }
+
   /** Everything an agent run needs before the session is created. */
   async _prepareAgentRun(task, runtime, signal) {
     const { randomUUID } = await import('node:crypto');
     let createUserMessage = (m) => m;
-    try {
-      const llmModule = await import('@deepseek-ai/dsh-llm');
-      if (llmModule && typeof llmModule.createUserMessage === 'function') {
-        createUserMessage = llmModule.createUserMessage;
-      }
-    } catch {}
-    let sessionModule = null;
-    try {
-      sessionModule = await import('@deepseek-ai/dsh-session');
-    } catch {}
+    const llmModule = await bestEffort('import-dsh-llm', () => import('@deepseek-ai/dsh-llm'));
+    if (llmModule && typeof llmModule.createUserMessage === 'function') {
+      createUserMessage = llmModule.createUserMessage;
+    }
+    const sessionModule = await bestEffort('import-dsh-session', () => import('@deepseek-ai/dsh-session'));
 
     const targetSessionId = resolveTargetSessionId(task.targetSessionId, task.targetSessionReset);
 
@@ -550,12 +316,10 @@ export class SessionRunner {
   _shapeAgentPrompt(task, runtime) {
     const prompt = String(task.prompt || '');
     if (runtime === 'skill' && task.skillName) {
-      return `Use the DSH skill "${task.skillName}" for this task:
-${prompt}`;
+      return `Use the DSH skill "${task.skillName}" for this task:\n${prompt}`;
     }
     if (runtime === 'workflow' && task.workflowName) {
-      return `Execute this through the DSH workflow "${task.workflowName}" step by step:
-${prompt}`;
+      return `Execute this through the DSH workflow "${task.workflowName}" step by step:\n${prompt}`;
     }
     return prompt;
   }
@@ -665,23 +429,23 @@ ${prompt}`;
   /** Token usage reported by the session, when the core exposes it. */
   _extractUsage(handle) {
     const usage = { inputTokens: 0, outputTokens: 0, cacheReadTokens: 0 };
-    try {
+    bestEffort('extract-session-usage', () => {
       const sessionUsage = handle.agent.session?.usage || handle.agent.usage;
       if (sessionUsage) {
         usage.inputTokens = sessionUsage.inputTokens || sessionUsage.promptTokens || 0;
         usage.outputTokens = sessionUsage.outputTokens || sessionUsage.completionTokens || 0;
         usage.cacheReadTokens = sessionUsage.cacheReadTokens || sessionUsage.cachedTokens || 0;
       }
-    } catch {}
+    });
     return usage;
   }
 
   /** Dispose the session, archive it best-effort, drop the worktree (#30, #29). */
   async _disposeAgentRun(task, prep, handle) {
     let archivedSessionId = null;
-    try {
-      archivedSessionId = (handle && handle.agent && handle.agent.session && handle.agent.session.id) || null;
-    } catch {}
+    archivedSessionId = bestEffort('get-archived-session-id', () => {
+      return (handle && handle.agent && handle.agent.session && handle.agent.session.id) || null;
+    }) || null;
     try {
       if (handle && typeof handle.dispose === 'function') {
         await handle.dispose();
@@ -694,12 +458,12 @@ ${prompt}`;
     // Best-effort: keep ephemeral cron sessions out of the main chat list (#30).
     // Persistent sessions (targetSessionId configured) stay unarchived so users can interact with them (#143).
     if (archivedSessionId && this.ctx && this.ctx.get && !prep.targetSessionId) {
-      try {
+      bestEffort('archive-session-cleanup', () => {
         const sessions = this.ctx.get('sessions');
         if (sessions && typeof sessions.archive === 'function') {
           sessions.archive(archivedSessionId);
         }
-      } catch {}
+      });
     }
     // #29: dispose the isolated worktree (kept when keepWorktree is set).
     if (prep.taskWorktree && !task.keepWorktree) {
@@ -707,3 +471,4 @@ ${prompt}`;
     }
   }
 }
+

package/lib/runtimes.js

@@ -1,3 +1,4 @@
+import { bestEffort } from './best-effort.js';
 /**
  * Runtime invocation builders for non-LLM task types (#4, #5, #7, #8, #9, #38).
  *
@@ -68,9 +69,8 @@ function detectPython(task, cwd) {
   candidates.push(path.join(base, '.venv', 'Scripts', 'python.exe'));
   candidates.push(path.join(base, 'venv', 'bin', 'python'));
   for (const candidate of candidates) {
-    try {
-      if (fs.existsSync(candidate)) return candidate;
-    } catch {}
+    const exists = bestEffort('check-python-candidate', () => fs.existsSync(candidate));
+    if (exists) return candidate;
   }
   return process.platform === 'win32' ? 'python' : 'python3';
 }