@goodandready/dsh-cron 0.2.19 → 0.2.21

package/lib/routes.js

@@ -0,0 +1,194 @@
+import { randomUUID } from 'node:crypto';
+import { createCronApiHandler } from './api.js';
+import { createMetricsHandler } from './metrics.js';
+import { createExternalApiHandler, EXTERNAL_API_PREFIX } from './external-api.js';
+import { getModelsHandler } from './models-handler.js';
+import { chatStartHandler } from './chat-start.js';
+import { sendJson, rejectCrossOrigin, readBody, parseJsonBody } from './http-utils.js';
+import { recipesByCategory } from './recipes.js';
+import { sendTelegramMessage, createTelegramTaskKeyboard } from './telegram.js';
+import { createKanbanCard } from './integrations.js';
+import { sanitizeSettingsPayload, applySettingsToScope } from './settings.js';
+
+export function registerRoutes(ctx, { store, scheduler, getCronSettingsScope, recommendations }) {
+  // handler per route family; registered WITHOUT the trailing slash (#96)
+  ctx.effect(() => ctx.webServer.register({
+    kind: 'prefix',
+    path: '/dsh-cron/tasks',
+    handler: createCronApiHandler(store, scheduler, { recommendations })
+  }), 'dsh-cron: /tasks[...]');
+
+  // Alias route /dsh-cron/action/:id/:action for backward compatibility (#66)
+  ctx.effect(() => ctx.webServer.register({
+    kind: 'prefix',
+    path: '/dsh-cron/action',
+    handler: createCronApiHandler(store, scheduler, null)
+  }), 'dsh-cron: /action/:id/:action');
+
+  ctx.effect(() => ctx.webServer.register({
+    kind: 'prefix',
+    path: '/dsh-cron/telegram',
+    handler: createCronApiHandler(store, scheduler, null)
+  }), 'dsh-cron: /telegram[...]');
+
+  ctx.effect(() => ctx.webServer.register({
+    kind: 'prefix',
+    path: '/dsh-cron/heartbeat-ping',
+    handler: createCronApiHandler(store, scheduler, null)
+  }), 'dsh-cron: /heartbeat-ping[...]');
+
+  ctx.effect(() => ctx.webServer.register({
+    kind: 'prefix',
+    path: '/dsh-cron/schedule',
+    handler: createCronApiHandler(store, scheduler, null)
+  }), 'dsh-cron: /schedule[...]');
+
+  // GET /dsh-cron/metrics (#53) — Prometheus text exposition
+  ctx.effect(() => ctx.webServer.register({
+    kind: 'exact',
+    path: '/dsh-cron/metrics',
+    handler: createMetricsHandler({ store, scheduler })
+  }), 'dsh-cron: /metrics');
+
+  // External REST API under /dsh-cron/api/* (#54, ADR-0001): the only surface
+  // guarded by a bearer token, so CI and host automation can drive the
+  // scheduler without a browser session. The token is read per request, so a
+  // settings change applies without a restart.
+  ctx.effect(() => ctx.webServer.register({
+    kind: 'prefix',
+    path: EXTERNAL_API_PREFIX,
+    handler: createExternalApiHandler({
+      store,
+      scheduler,
+      getToken: () => store.getSettings().apiToken || ''
+    })
+  }), 'dsh-cron: /api[...]');
+
+  // GET /dsh-cron/models
+  ctx.effect(() => ctx.webServer.register({
+    kind: 'exact',
+    path: '/dsh-cron/models',
+    handler: async (req, res) => {
+      await getModelsHandler(ctx, req, res, sendJson);
+    }
+  }), 'dsh-cron: /models');
+
+  // POST /dsh-cron/chat/start
+  ctx.effect(() => ctx.webServer.register({
+    kind: 'exact',
+    path: '/dsh-cron/chat/start',
+    handler: async (req, res) => {
+      if (req.method === 'POST' && rejectCrossOrigin(req, res)) return;
+      await chatStartHandler(ctx, req, res, parseJsonBody, sendJson, randomUUID);
+    }
+  }), 'dsh-cron: /chat/start');
+
+  // GET /dsh-cron/recipes (#48): the built-in recipe catalog.
+  ctx.effect(() => ctx.webServer.register({
+    kind: 'exact',
+    path: '/dsh-cron/recipes',
+    handler: async (req, res) => {
+      try {
+        if (req.method !== 'GET') {
+          sendJson(res, 405, { ok: false, error: 'Method not allowed' });
+          return;
+        }
+        const categories = recipesByCategory();
+        const recipes = categories.reduce((acc, category) => acc.concat(category.recipes), []);
+        sendJson(res, 200, { ok: true, categories, recipes });
+      } catch (err) {
+        sendJson(res, err.statusCode || 500, { ok: false, error: err.message });
+      }
+    }
+  }), 'dsh-cron: /recipes');
+
+  // GET /dsh-cron/heartbeat (#16): liveness probe for external monitors.
+  ctx.effect(() => ctx.webServer.register({
+    kind: 'exact',
+    path: '/dsh-cron/heartbeat',
+    handler: async (req, res) => {
+      try {
+        const tasks = store.list({ status: 'active' });
+        const lastRuns = tasks.map((t) => t.lastRunAt || 0);
+        sendJson(res, 200, {
+          ok: true,
+          activeTasks: tasks.length,
+          running: scheduler.runningCount(),
+          lastRunAt: lastRuns.length ? Math.max(...lastRuns) : null,
+          serverTime: Date.now(),
+        });
+      } catch (err) {
+        sendJson(res, 500, { ok: false, error: err.message });
+      }
+    }
+  }), 'dsh-cron: /heartbeat');
+
+  // POST /dsh-cron/telegram/test
+  ctx.effect(() => ctx.webServer.register({
+    kind: 'exact',
+    path: '/dsh-cron/telegram/test',
+    handler: async (req, res) => {
+      try {
+        if (req.method !== 'POST') {
+          sendJson(res, 405, { ok: false, error: 'Method not allowed' });
+          return;
+        }
+        if (rejectCrossOrigin(req, res)) return;
+        const { body, error } = await readBody(req, res);
+        if (error) return;
+        const settings = store.getSettings();
+        const botToken = body.botToken || settings.botToken;
+        const chatId = body.chatId || settings.chatId;
+
+        if (!botToken || !chatId) {
+          sendJson(res, 400, { ok: false, error: 'botToken or chatId is not configured' });
+          return;
+        }
+
+        const text = `🔔 *dsh-cron test notification*\n\nConnection between DSH Cron and Telegram is working! Checked at: \`${new Date().toISOString()}\``;
+        const replyMarkup = createTelegramTaskKeyboard(undefined, undefined);
+        await sendTelegramMessage({ botToken, chatId, text, replyMarkup });
+        sendJson(res, 200, { ok: true, message: 'Test message sent successfully' });
+      } catch (err) {
+        sendJson(res, 500, { ok: false, error: err.message });
+      }
+    }
+  }), 'dsh-cron: /telegram/test');
+
+  // POST /dsh-cron/kanban/test
+  ctx.effect(() => ctx.webServer.register({
+    kind: 'exact',
+    path: '/dsh-cron/kanban/test',
+    handler: async (req, res) => {
+      try {
+        if (req.method !== 'POST') {
+          sendJson(res, 405, { ok: false, error: 'Method not allowed' });
+          return;
+        }
+        if (rejectCrossOrigin(req, res)) return;
+        const { body, error } = await readBody(req, res);
+        if (error) return;
+        const settings = store.getSettings();
+        const kanbanBaseUrl = body.kanbanBaseUrl || settings.kanbanBaseUrl || 'http://127.0.0.1:3000';
+
+        const result = await createKanbanCard({
+          title: '[Test] dsh-cron -> Kanban connectivity check',
+          body: `Test card created automatically by the \`dsh-cron\` module at ${new Date().toISOString()}.`,
+          board: 'main',
+          column: 'backlog',
+          labels: ['cron', 'test'],
+          kanbanBaseUrl
+        });
+
+        if (result.success) {
+          sendJson(res, 200, { ok: true, task: result.task });
+        } else {
+          sendJson(res, 500, { ok: false, error: result.error });
+        }
+      } catch (err) {
+        sendJson(res, 500, { ok: false, error: err.message });
+      }
+    }
+  }), 'dsh-cron: /kanban/test');
+}
+

package/lib/runner-external.js

@@ -0,0 +1,238 @@
+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) {
+  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;
+    }
+  }
+}
+
+/**
+ * #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 settings = 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 : [];
+      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 stdout = '';
+    let stderr = '';
+    const maxBuffer = 10 * 1024 * 1024;
+    const isPosix = process.platform !== 'win32';
+
+    const killProcessTree = (sig = 'SIGTERM') => {
+      terminateProcessTree(child, sig, {
+        isPosix,
+        execFn: (cmd) => {
+          bestEffort('exec-cmd', () => exec(cmd, { windowsHide: true }, () => {}));
+        }
+      });
+    };
+
+    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,
+      });
+    });
+  });
+}
+

package/lib/runner-worktree.js

@@ -0,0 +1,55 @@
+import { bestEffort } from './best-effort.js';
+
+/**
+ * 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 && ctx && typeof ctx.get === 'function') {
+    const resolved = bestEffort('resolve-workspace-path', () => {
+      const workspaces = ctx.get('workspaces');
+      if (workspaces && typeof workspaces.get === 'function') {
+        const ws = workspaces.get(task.workspaceId);
+        return ws && ws.path ? String(ws.path) : null;
+      }
+      return null;
+    });
+    if (resolved) return 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) {
+        console.warn(`[dsh-cron] task worktree kept (not removable without force): ${wtPath} — ${String(stderr || err.message).trim()}`);
+      }
+      execFile('git', ['-C', cwd, 'worktree', 'prune'], () => resolve());
+    });
+  });
+}
+