@goodandready/dsh-cron 0.3.22 → 0.3.23

package/lib/chat-start.js

@@ -18,7 +18,12 @@ export async function chatStartHandler(ctx, req, res, parseJsonBody, sendJson, r
       return;
     }
 
-    const agents = ctx.agents;
+    let agents = null;
+    try {
+      agents = (ctx && typeof ctx.get === 'function' ? ctx.get('agents') : null) || (ctx && ctx.agents);
+    } catch {
+      agents = null;
+    }
     if (!agents || typeof agents.create !== 'function') {
       sendJson(res, 500, { ok: false, error: 'The agents service is unavailable in DSH' });
       return;
@@ -45,7 +50,13 @@ export async function chatStartHandler(ctx, req, res, parseJsonBody, sendJson, r
       (ctx.logger || console).debug?.('[dsh-cron] @deepseek-ai/dsh-session SessionId unavailable, using string fallback:', err?.message || err);
     }
 
-    const defaultSel = ctx.get('agentDefaultModel')?.currentSelection?.();
+    let defaultSel = null;
+    try {
+      const adm = (ctx && typeof ctx.get === 'function' ? ctx.get('agentDefaultModel') : null) || (ctx && ctx.agentDefaultModel);
+      defaultSel = adm?.currentSelection?.();
+    } catch {
+      defaultSel = null;
+    }
     const provider = body.provider || defaultSel?.provider;
     const model = body.model || defaultSel?.model;
 

package/lib/index.js

@@ -1,3 +1,16 @@
+import {
+  TaskSchema,
+  validateTaskRecord,
+  safeValidateTaskRecord,
+  validateTaskPatch,
+} from './task-schema.js';
+
+export {
+  TaskSchema,
+  validateTaskRecord,
+  safeValidateTaskRecord,
+  validateTaskPatch,
+};
 import fs from 'node:fs';
 import path from 'node:path';
 import { bestEffort } from './best-effort.js';
@@ -95,7 +108,7 @@ export {
 };
 
 export const name = '@goodandready/dsh-cron';
-export const inject = ['tools', 'webServer', 'llm', 'agents', 'agentDefaultModel', 'credentials', 'workspaceRegistry'];
+export const inject = ['tools', 'webServer'];
 
 import { executeCreateTask } from './task-create.js';
 import {

package/lib/models-handler.js

@@ -3,11 +3,18 @@ export async function getModelsHandler(ctx, req, res, sendJson) {
     sendJson(res, 405, { ok: false, error: 'Method not allowed' });
     return;
   }
-  const current = ctx.get('agentDefaultModel')?.currentSelection?.() ?? null;
+  let current = null;
+  try {
+    const adm = (ctx && typeof ctx.get === 'function' ? ctx.get('agentDefaultModel') : null) || (ctx && ctx.agentDefaultModel);
+    current = adm?.currentSelection?.() ?? null;
+  } catch {
+    current = null;
+  }
   let providers = [];
   try {
-    if (ctx.llm && typeof ctx.llm.listProviders === 'function') {
-      providers = (ctx.llm.listProviders() ?? []).map((p) => ({ id: p.id, name: p.name ?? p.id }));
+    const llm = (ctx && typeof ctx.get === 'function' ? ctx.get('llm') : null) || (ctx && ctx.llm);
+    if (llm && typeof llm.listProviders === 'function') {
+      providers = (llm.listProviders() ?? []).map((p) => ({ id: p.id, name: p.name ?? p.id }));
     }
   } catch {
     providers = [];
@@ -22,8 +29,9 @@ export async function getModelsHandler(ctx, req, res, sendJson) {
 
   try {
     let rows = [];
-    if (ctx.llm && typeof ctx.llm.listModels === 'function') {
-      rows = await ctx.llm.listModels(wanted);
+    const llm = (ctx && typeof ctx.get === 'function' ? ctx.get('llm') : null) || (ctx && ctx.llm);
+    if (llm && typeof llm.listModels === 'function') {
+      rows = await llm.listModels(wanted);
     }
     sendJson(res, 200, {
       current,
@@ -33,4 +41,4 @@ export async function getModelsHandler(ctx, req, res, sendJson) {
   } catch {
     sendJson(res, 200, { current, providers, models: [] });
   }
-}
+}

package/lib/routes.js

@@ -22,6 +22,30 @@ const LOCALES_JSON = readFileSync(new URL('./locales.json', import.meta.url), 'u
 
 
 export function registerRoutes(ctx, { store, scheduler, recommendations }) {
+  // Health probe route (#384)
+  ctx.effect(() => ctx.webServer.register({
+    kind: 'exact',
+    path: '/dsh-cron/health',
+    handler: (req, res) => {
+      if (req.method !== 'GET') {
+        res.writeHead(405, { 'content-type': 'text/plain; charset=utf-8' });
+        res.end('GET only');
+        return;
+      }
+      res.writeHead(200, {
+        'content-type': 'application/json; charset=utf-8',
+        'cache-control': 'no-store'
+      });
+      const tasks = typeof store?.list === 'function' ? store.list().length : 0;
+      res.end(JSON.stringify({
+        status: 'ok',
+        plugin: '@goodandready/dsh-cron',
+        tasks,
+        uptimeSec: Math.floor(process.uptime()),
+      }));
+    }
+  }), 'dsh-cron: /health');
+
   // Client locales route (#374)
   ctx.effect(() => ctx.webServer.register({
     kind: 'exact',

package/lib/runner.js

@@ -79,6 +79,40 @@ export class SessionRunner {
     this.store = store;
   }
 
+  _getAgentsService() {
+    if (!this.ctx) return null;
+    try {
+      if (typeof this.ctx.get === 'function') {
+        const svc = this.ctx.get('agents');
+        if (svc) return svc;
+      }
+    } catch (_err) {
+      // service unavailable via ctx.get
+    }
+    try {
+      return this.ctx.agents || null;
+    } catch (_err) {
+      return null;
+    }
+  }
+
+  _getSessionService() {
+    if (!this.ctx) return null;
+    try {
+      if (typeof this.ctx.get === 'function') {
+        const svc = this.ctx.get('session');
+        if (svc) return svc;
+      }
+    } catch (_err) {
+      // service unavailable via ctx.get
+    }
+    try {
+      return this.ctx.session || null;
+    } catch (_err) {
+      return null;
+    }
+  }
+
   async execute(task, options = {}) {
     const timeoutSeconds = Number(task.timeoutSeconds) > 0 ? Number(task.timeoutSeconds) : 1800;
     const timeoutMs = timeoutSeconds * 1000;
@@ -234,12 +268,14 @@ export class SessionRunner {
       }
 
       // 2. Agent session, when the harness exposes one
-      if (this.ctx && this.ctx.agents && typeof this.ctx.agents.create === 'function') {
+      const agentsSvc = this._getAgentsService();
+      if (agentsSvc && typeof agentsSvc.create === 'function') {
         return this._runAgentSession(effectiveTask, runtime, signal, options);
       }
 
       // 3. Legacy session service
-      if (this.ctx && this.ctx.session && typeof this.ctx.session.create === 'function') {
+      const sessionSvc = this._getSessionService();
+      if (sessionSvc && typeof sessionSvc.create === 'function') {
         return this._runLegacySession(effectiveTask, options);
       }
 
@@ -270,12 +306,14 @@ export class SessionRunner {
     }
 
     // 2. Agent session, when the harness exposes one
-    if (this.ctx && this.ctx.agents && typeof this.ctx.agents.create === 'function') {
+    const agentsSvc2 = this._getAgentsService();
+    if (agentsSvc2 && typeof agentsSvc2.create === 'function') {
       return this._runAgentSession(task, runtime, signal, options);
     }
 
     // 3. Legacy session service
-    if (this.ctx && this.ctx.session && typeof this.ctx.session.create === 'function') {
+    const sessionSvc2 = this._getSessionService();
+    if (sessionSvc2 && typeof sessionSvc2.create === 'function') {
       return this._runLegacySession(task, options);
     }
 
@@ -484,9 +522,10 @@ export class SessionRunner {
 
       // If targetSessionId is set, attempt to resume the existing session (#143, #346, GH #9)
       let resumeFailure = null;
-      if (prep.targetSessionId && this.ctx.agents && typeof this.ctx.agents.resume === 'function') {
+      const agents = this._getAgentsService();
+      if (prep.targetSessionId && agents && typeof agents.resume === 'function') {
         try {
-          handle = await this.ctx.agents.resume({
+          handle = await agents.resume({
             sessionId: prep.targetSessionId,
             resumeSessionId: prep.targetSessionId,
             meta: {
@@ -508,7 +547,7 @@ export class SessionRunner {
       // Create new session if not resumed
       if (!handle) {
         try {
-          handle = await this.ctx.agents.create({
+          handle = await agents.create({
             sessionId: prep.mintSessionId(),
             meta: {
               cwd: prep.cwd,

package/lib/task-create.js

@@ -1,3 +1,4 @@
+import { validateTaskRecord } from './task-schema.js';
 import { sanitizeSwarmConfig } from './swarm.js';
 import { sanitizeBranchRules } from './branching.js';
 import { sanitizePromptHistory } from './prompt-evolver.js';
@@ -132,7 +133,8 @@ export function executeCreateTask(store, scheduler, args) {
     throw new Error(dagCheck.error);
   }
 
-  const task = store.set(taskData);
+  const validTask = validateTaskRecord(taskData);
+  const task = store.set(validTask);
   scheduler.scheduleTask(task);
   return {
     success: true,

package/lib/task-schema.js

@@ -0,0 +1,175 @@
+import z from '@deepseek-ai/schemastery';
+import { normalizeTaskType } from './runtimes.js';
+import { validateTaskType, PATCHABLE_TASK_FIELDS } from './task-transfer.js';
+import { CHANNEL_IDS } from './channels.js';
+
+export const TaskSchema = z.object({
+  id: z.string(),
+  title: z.string().required(),
+  schedule: z.string().required(),
+  scheduleText: z.string(),
+  type: z.string().default('llm'),
+  prompt: z.string().default(''),
+  delivery: z.string().default('isolated'),
+  status: z.string().default('active'),
+  provider: z.string(),
+  model: z.string(),
+  fallbackProvider: z.string(),
+  fallbackModel: z.string(),
+  silentRule: z.string().default(''),
+  inspectOnFailure: z.boolean().default(false),
+  agentPreset: z.string().default(''),
+  targetSessionId: z.string().default(''),
+  targetSessionReset: z.string().default('never'),
+  sessionTitle: z.string().default(''),
+  timezone: z.string().default(''),
+  misfirePolicy: z.string().default('skip'),
+  maxRetries: z.number().default(0),
+  retryBackoffMs: z.number().default(30000),
+  permissionPreset: z.string().default('default'),
+  captureGitDiff: z.boolean(),
+  kanbanMode: z.string().default('none'),
+  channels: z.array(z.string()).default([]),
+  template: z.string().default(''),
+  env: z.any(),
+  cwd: z.string().default(''),
+  workspaceId: z.string().default(''),
+  worktree: z.boolean().default(false),
+  keepWorktree: z.boolean().default(false),
+  httpMethod: z.string().default('GET'),
+  httpUrl: z.string().default(''),
+  httpHeaders: z.any(),
+  httpBody: z.string().default(''),
+  sshProfileId: z.string().default(''),
+  sshTarget: z.string().default(''),
+  sshPort: z.number().default(0),
+  sshKeyPath: z.string().default(''),
+  dockerImage: z.string().default(''),
+  pythonPath: z.string().default(''),
+  nodePath: z.string().default(''),
+  skillName: z.string().default(''),
+  workflowName: z.string().default(''),
+  webhookEnabled: z.boolean().default(false),
+  webhookToken: z.string(),
+  webhookSecret: z.string(),
+  webhookDebounceMs: z.number(),
+  webhookTrigger: z.any(),
+  onSuccess: z.string().default(''),
+  onFailure: z.string().default(''),
+  heartbeatIntervalSeconds: z.number().default(0),
+  gracePeriodSeconds: z.number().default(300),
+  preflightType: z.string().default('none'),
+  preflightTarget: z.string().default(''),
+  preflightCommand: z.string(),
+  preflightScript: z.string(),
+  concurrencyGroup: z.string().default('default'),
+  priority: z.number().default(5),
+  selfHealingCommand: z.string().default(''),
+  autoDiagnose: z.boolean().default(false),
+  notifyTelegram: z.boolean(),
+  onlyOnFailure: z.boolean(),
+  timeoutSeconds: z.number().default(1800),
+  overlapPolicy: z.string().default('skip'),
+  oneShot: z.boolean().default(false),
+  targetTimestamp: z.number(),
+  nextRunAt: z.number(),
+  costLimitUsd: z.number(),
+  dailyCostLimitUsd: z.number(),
+  tokenLimit: z.number(),
+  pausedReason: z.string(),
+  validators: z.any(),
+  requireApproval: z.boolean().default(false),
+  fileWatch: z.any(),
+  dependsOn: z.array(z.string()).default([]),
+  joinPolicy: z.string().default('all_success'),
+  adaptive: z.any(),
+  adaptiveState: z.any(),
+  promptVersion: z.number(),
+  promptHistory: z.any(),
+  branchRules: z.any(),
+  elseTask: z.string(),
+  autoHeal: z.boolean(),
+  selfHealing: z.any(),
+  revisions: z.any(),
+  previousPrompt: z.string(),
+  previousScript: z.string(),
+  swarm: z.any(),
+  gitDiff: z.any(),
+  schemaVersion: z.number().default(1),
+  createdAt: z.number(),
+  updatedAt: z.number(),
+});
+
+export function validateTaskRecord(data) {
+  if (!data || typeof data !== 'object') {
+    throw new TypeError('Task record must be an object');
+  }
+  if (data.title !== undefined && typeof data.title !== 'string') {
+    throw new Error('Task schema validation failed: title must be a string');
+  }
+  const title = String(data.title || '').trim();
+  if (!title) {
+    throw new Error('Task title cannot be empty');
+  }
+  if (data.schedule !== undefined && typeof data.schedule !== 'string') {
+    throw new Error('Task schema validation failed: schedule must be a string');
+  }
+  const schedule = String(data.schedule || '').trim();
+  if (!schedule) {
+    throw new Error('Task schedule cannot be empty');
+  }
+
+  const cleanType = normalizeTaskType(data.type);
+  const typeError = validateTaskType(cleanType, data);
+  if (typeError) {
+    throw new Error(typeError);
+  }
+
+  let validated;
+  try {
+    validated = TaskSchema({
+      ...data,
+      title,
+      schedule,
+      type: cleanType,
+    });
+  } catch (err) {
+    throw new Error(`Task schema validation failed: ${err.message}`);
+  }
+
+  // Filter channels to known channel ids if present
+  if (Array.isArray(validated.channels)) {
+    validated.channels = validated.channels.filter((c) => CHANNEL_IDS.includes(c));
+  }
+
+  // Strip undefined keys
+  for (const k of Object.keys(validated)) {
+    if (validated[k] === undefined) {
+      delete validated[k];
+    }
+  }
+
+  return validated;
+}
+
+export function safeValidateTaskRecord(data) {
+  try {
+    const task = validateTaskRecord(data);
+    return { ok: true, task };
+  } catch (err) {
+    return { ok: false, error: err.message };
+  }
+}
+
+export function validateTaskPatch(patch) {
+  if (!patch || typeof patch !== 'object') {
+    return { ok: false, error: 'Task patch must be an object' };
+  }
+  const clean = {};
+  for (const [key, value] of Object.entries(patch)) {
+    if (PATCHABLE_TASK_FIELDS.includes(key)) {
+      clean[key] = value;
+    }
+  }
+  return { ok: true, patch: clean };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@goodandready/dsh-cron",
-  "version": "0.3.22",
+  "version": "0.3.23",
   "description": "Background automation runner for DSH: isolated agent runs, script/HTTP/SSH/Docker runtimes, cost guard, notifications, heartbeats.",
   "type": "module",
   "main": "lib/index.js",
@@ -22,7 +22,8 @@
     "test": "node --test test/*.test.mjs && node scripts/check-pack-size.mjs",
     "build:client": "node scripts/build-client.mjs",
     "pretest": "node scripts/build-client.mjs",
-    "preflight": "node scripts/ci-preflight.mjs"
+    "preflight": "node scripts/ci-preflight.mjs",
+    "test:engine": "node scripts/test-engines.mjs"
   },
   "keywords": [
     "dsh",
@@ -51,6 +52,14 @@
         "@deepseek-ai/dsh-client-locale",
         "@deepseek-ai/dsh-client-ui-slots"
       ]
+    },
+    "compatibility": {
+      "dshReleases": {
+        "0.2.1-rc.2": "compatible",
+        "0.2.1-rc.3": "compatible",
+        "0.2.1-rc.4": "compatible"
+      },
+      "dsh": ">=0.2.1-rc.2 <0.2.2-0"
     }
   },
   "dependencies": {