@goodandready/dsh-cron 0.2.27 → 0.2.29

package/lib/index.js

@@ -92,64 +92,26 @@ export const name = '@goodandready/dsh-cron';
 export const inject = ['tools', 'webServer', 'llm', 'agents', 'agentDefaultModel', 'credentials'];
 
 import { executeCreateTask } from './task-create.js';
-export { executeCreateTask };
-
-export const createTaskParameters = {
-  title: { type: 'string', description: 'Short task name', required: true },
-  schedule: { type: 'string', description: 'Schedule: cron ("0 9 * * *"), shorthand ("@daily", "@every 30m"), interval ("every 2h") or one-shot ("in 30m", "at: 2026-09-05T15:00:00Z")', required: true },
-  prompt: { type: 'string', description: 'Prompt/instruction for the agent at run time', required: true },
-  type: { type: 'string', enum: TASK_TYPES, description: 'Task type: llm | script | node | python | http | ssh | docker | skill | workflow' },
-  delivery: { type: 'string', enum: ['current', 'isolated'], description: 'Run mode: current (in the current chat) or isolated (separate session)' },
-  provider: { type: 'string', description: 'Model provider (optional)' },
-  inspectOnFailure: { type: 'boolean', description: 'Diagnose failed runs with a model and store the diagnosis with the run (agent tasks)' },
-  silentRule: { type: 'string', description: 'Plain-language condition for staying silent on a successful run (script/node/python/http tasks)' },
-  fallbackModel: { type: 'string', description: 'Model tried once more when the primary model fails (llm/skill/workflow tasks)' },
-  fallbackProvider: { type: 'string', description: 'Provider for the fallback model (defaults to the task provider)' },
-  model: { type: 'string', description: 'Model (optional)' },
-  timezone: { type: 'string', description: 'IANA time zone for the schedule, e.g. "Europe/Berlin" (optional, default = server local)' },
-  notifyTelegram: { type: 'boolean', description: 'Send the run report to Telegram' },
-  onlyOnFailure: { type: 'boolean', description: 'Send reports only for failures' },
-  timeoutSeconds: { type: 'number', description: 'Execution time limit in seconds' },
-  overlapPolicy: { type: 'string', enum: ['skip', 'queue', 'replace'], description: 'Overlap policy' },
-  misfirePolicy: { type: 'string', enum: ['skip', 'runOnce', 'catchUpAll'], description: 'What to do with a run missed during downtime' },
-  maxRetries: { type: 'number', description: 'Automatic retry attempts on failure (0 = off)' },
-  retryBackoffMs: { type: 'number', description: 'Base backoff between retries in ms, doubled per attempt' },
-  permissionPreset: { type: 'string', enum: ['default', 'read-only', 'workspace-write', 'full'], description: 'Permission preset applied to the task session' },
-  kanbanMode: { type: 'string', enum: ['none', 'on_failure', 'always'], description: 'Create a dsh-kanban card for runs' },
-  channels: { type: 'array', items: { type: 'string', enum: CHANNEL_IDS }, description: 'Notification channels for this task; empty = legacy telegram/kanban flags' },
-  template: { type: 'string', description: 'Notification template with {title} {status} {output} {error} {duration} placeholders; empty = built-in text' },
-  env: { type: 'object', additionalProperties: true, description: 'Environment variables for external runtimes (KEY: value); do not store secrets here' },
-  cwd: { type: 'string', description: 'Working directory for the run (external runtimes and agent sessions)' },
-  workspaceId: { type: 'string', description: 'Workspace bound to the task; resolved through the harness' },
-  worktree: { type: 'boolean', description: 'Run code-modifying agent tasks in an isolated git worktree' },
-  keepWorktree: { type: 'boolean', description: 'Keep the created worktree after the run' },
-  nodePath: { type: 'string', description: 'Node.js binary for node tasks (default: the harness runtime)' },
-  pythonPath: { type: 'string', description: 'Python interpreter for python tasks (default: auto-detected venv)' },
-  httpMethod: { type: 'string', description: 'HTTP method for http tasks' },
-  httpUrl: { type: 'string', description: 'URL for http tasks' },
-  httpHeaders: { type: 'object', additionalProperties: true, description: 'Headers for http tasks' },
-  httpBody: { type: 'string', description: 'Request body for http tasks' },
-  sshProfileId: { type: 'string', description: 'dsh-remote-workspace profile id that provides host and credentials' },
-  sshTarget: { type: 'string', description: 'Fallback user@host when no remote-workspace profile is used' },
-  sshPort: { type: 'number', description: 'SSH port (with sshTarget fallback)' },
-  sshKeyPath: { type: 'string', description: 'Private key path (with sshTarget fallback)' },
-  dockerImage: { type: 'string', description: 'Container image for docker tasks' },
-  skillName: { type: 'string', description: 'DSH skill name for skill tasks' },
-  workflowName: { type: 'string', description: 'DSH workflow name for workflow tasks' },
-};
+import {
+  cronToolParameters,
+  cronToolOutput,
+  executeCronTool,
+  rejectLegacyTool,
+  LEGACY_TOOL_NAMES,
+  LEGACY_ACTION_MAP,
+} from './cron-tool.js';
 
-const createTaskOutput = {
-  schema: {
-    type: 'object',
-    additionalProperties: true,
-    properties: {
-      success: { type: 'boolean' },
-      message: { type: 'string' },
-      task: { type: 'object', additionalProperties: true }
-    }
-  },
-  render: (_args, val) => [{ type: 'text', text: val.message || JSON.stringify(val) }]
+export {
+  executeCreateTask,
+  cronToolParameters,
+  cronToolOutput,
+  executeCronTool,
+  rejectLegacyTool,
+  LEGACY_TOOL_NAMES,
+  LEGACY_ACTION_MAP,
 };
+export const createTaskParameters = cronToolParameters;
+export const createTaskOutput = cronToolOutput;
 
 export function apply(ctx, rawConfig) {
   const config = unwrapConfig(rawConfig);
@@ -286,243 +248,12 @@ export function apply(ctx, rawConfig) {
     }
   }), 'dsh-cron: /settings');
 
-  // 2. Tools
-  ctx.tools.register(defineTool({
-    name: 'cron_create_task',
-    description: 'Create a new scheduled cron task (cron schedule, or one-shot via "at: <ISO timestamp>" or "in 20m")',
-    parameters: createTaskParameters,
-    output: createTaskOutput,
-    execute: async (args) => executeCreateTask(store, scheduler, args)
-  }));
-
-  // Alias tool cron_schedule_task for compatibility with agent prompts (#70)
-  ctx.tools.register(defineTool({
-    name: 'cron_schedule_task',
-    description: 'Alias for cron_create_task: create a new scheduled cron task',
-    parameters: createTaskParameters,
-    output: createTaskOutput,
-    execute: async (args) => executeCreateTask(store, scheduler, args)
-  }));
-
-  ctx.tools.register(defineTool({
-    name: 'cron_list_tasks',
-    description: 'List all scheduled cron tasks',
-    parameters: {
-      status: { type: 'string', enum: ['all', 'active', 'paused', 'completed'], description: 'Filter by status' }
-    },
-    output: {
-      schema: {
-        type: 'object',
-        additionalProperties: true,
-        properties: {
-          count: { type: 'number' },
-          tasks: { type: 'array', items: { type: 'object', additionalProperties: true } }
-        }
-      },
-      render: (_args, val) => [{ type: 'text', text: `Total tasks: ${val.count}` }]
-    },
-    execute: async (args) => {
-      const tasks = store.list({ status: args.status || 'all' });
-      return {
-        count: tasks.length,
-        tasks: tasks.map(t => ({
-          id: t.id,
-          title: t.title,
-          schedule: t.scheduleText || t.schedule,
-          status: t.status,
-          nextRunAt: t.nextRunAt ? new Date(t.nextRunAt).toISOString() : null,
-          lastStatus: t.lastStatus,
-          totalTokens: t.totalTokens || 0,
-          totalCostUsd: t.totalCostUsd || 0,
-          oneShot: Boolean(t.oneShot),
-        }))
-      };
-    }
-  }));
-
-  ctx.tools.register(defineTool({
-    name: 'cron_pause_task',
-    description: 'Pause a task by its ID',
-    parameters: {
-      id: { type: 'string', description: 'Task identifier', required: true }
-    },
-    output: {
-      schema: {
-        type: 'object',
-        additionalProperties: true,
-        properties: {
-          success: { type: 'boolean' },
-          message: { type: 'string' }
-        }
-      },
-      render: (_args, val) => [{ type: 'text', text: val.message }]
-    },
-    execute: async (args) => {
-      // A config-owned task cannot be paused from here either: the next start
-      // would resume it, and the agent would have reported a change that never
-      // happened (#50 review finding).
-      if (isConfigOwned(store.get(args.id))) return { success: false, message: configOwnedMessage(args.id) };
-      const task = scheduler.pauseTask(args.id);
-      if (!task) return { success: false, message: 'Task not found' };
-      return { success: true, message: `Task "${task.title}" paused` };
-    }
-  }));
-
-  ctx.tools.register(defineTool({
-    name: 'cron_resume_task',
-    description: 'Resume a paused task',
-    parameters: {
-      id: { type: 'string', description: 'Task identifier', required: true }
-    },
-    output: {
-      schema: {
-        type: 'object',
-        additionalProperties: true,
-        properties: {
-          success: { type: 'boolean' },
-          message: { type: 'string' }
-        }
-      },
-      render: (_args, val) => [{ type: 'text', text: val.message }]
-    },
-    execute: async (args) => {
-      if (isConfigOwned(store.get(args.id))) return { success: false, message: configOwnedMessage(args.id) };
-      const task = scheduler.resumeTask(args.id);
-      if (!task) return { success: false, message: 'Task not found' };
-      return { success: true, message: `Task "${task.title}" resumed (${task.scheduleText})` };
-    }
-  }));
-
+  // 2. Tools: unified background automation runner (Issue #196: 9 tools -> 1)
   ctx.tools.register(defineTool({
-    name: 'cron_delete_task',
-    description: 'Delete a task by its ID',
-    parameters: {
-      id: { type: 'string', description: 'Task identifier', required: true }
-    },
-    output: {
-      schema: {
-        type: 'object',
-        additionalProperties: true,
-        properties: {
-          success: { type: 'boolean' },
-          message: { type: 'string' }
-        }
-      },
-      render: (_args, val) => [{ type: 'text', text: val.message }]
-    },
-    execute: async (args) => {
-      // Deleting a config-owned task would also drop its run history, and the
-      // task would come back at the next start without it.
-      if (isConfigOwned(store.get(args.id))) return { success: false, message: configOwnedMessage(args.id) };
-      scheduler.pauseTask(args.id);
-      const ok = store.delete(args.id);
-      return { success: ok, message: ok ? 'Task deleted' : 'Task not found' };
-    }
-  }));
-
-  ctx.tools.register(defineTool({
-    name: 'cron_get_task',
-    description: 'Read the full configuration of one scheduled task, including fields that are not visible in the task list',
-    parameters: {
-      id: { type: 'string', description: 'Task identifier', required: true }
-    },
-    output: {
-      schema: {
-        type: 'object',
-        additionalProperties: true,
-        properties: {
-          success: { type: 'boolean' },
-          message: { type: 'string' },
-          task: { type: 'object', additionalProperties: true }
-        }
-      },
-      render: (_args, val) => [{ type: 'text', text: val.message }]
-    },
-    execute: async (args) => {
-      const task = store.get(args.id);
-      if (!task) return { success: false, message: 'Task not found' };
-      const summary = [
-        `Task "${task.title}" (${task.id})`,
-        `type: ${task.type || 'llm'}`,
-        `schedule: ${task.scheduleText || task.schedule}`,
-        `status: ${task.status}`,
-        task.type === 'llm' || !task.type ? `model: ${task.model || '(default)'}${task.fallbackModel ? ` (fallback: ${task.fallbackModel})` : ''}` : null,
-        `channels: ${Array.isArray(task.channels) && task.channels.length ? task.channels.join(', ') : '(legacy flags)'}`,
-        `prompt: ${String(task.prompt || '').slice(0, 500)}`,
-      ].filter(Boolean).join(String.fromCharCode(10));
-      return { success: true, message: summary, task };
-    }
-  }));
-
-  ctx.tools.register(defineTool({
-    name: 'cron_update_task',
-    description: 'Change an existing scheduled task. Ask the user what to change first. Switching a task to a code-executing type (script/node/python/ssh/docker) is refused unless confirmCodeSwitch is set, which requires the user to have agreed explicitly. Only the documented task fields can be changed.',
-    parameters: {
-      id: { type: 'string', description: 'Task identifier', required: true },
-      confirmCodeSwitch: { type: 'boolean', description: 'Set to true only after the user explicitly agreed to switch this task into a type that executes code' },
-      title: { type: 'string', description: 'New title' },
-      schedule: { type: 'string', description: 'New schedule (cron expression or interval)' },
-      prompt: { type: 'string', description: 'New prompt or command' },
-      type: { type: 'string', enum: TASK_TYPES, description: 'New execution type' },
-      model: { type: 'string', description: 'New model for agent tasks' },
-      fallbackModel: { type: 'string', description: 'New fallback model' },
-      provider: { type: 'string', description: 'New provider' },
-      channels: { type: 'array', items: { type: 'string', enum: CHANNEL_IDS }, description: 'New delivery channels' },
-      template: { type: 'string', description: 'New message template' },
-      onlyOnFailure: { type: 'boolean', description: 'Deliver only on failures' },
-      timeoutSeconds: { type: 'number', description: 'New execution timeout in seconds' },
-      overlapPolicy: { type: 'string', enum: ['skip', 'queue', 'replace'], description: 'New overlap policy' },
-      maxRetries: { type: 'number', description: 'New retry count' },
-      kanbanMode: { type: 'string', enum: ['none', 'on_failure', 'always'], description: 'New Kanban policy' },
-      timezone: { type: 'string', description: 'New IANA time zone' },
-      cwd: { type: 'string', description: 'New working directory' },
-      env: { type: 'object', additionalProperties: true, description: 'New environment variables (KEY: value)' }
-    },
-    output: {
-      schema: {
-        type: 'object',
-        additionalProperties: true,
-        properties: {
-          success: { type: 'boolean' },
-          message: { type: 'string' }
-        }
-      },
-      render: (_args, val) => [{ type: 'text', text: val.message }]
-    },
-    execute: async (args) => {
-      const { id, confirmCodeSwitch, ...patch } = args || {};
-      if (!id) return { success: false, message: 'A task id is required' };
-      const result = applyTaskPatch({ store, scheduler, id, body: patch, allowCodeSwitch: confirmCodeSwitch === true });
-      if (!result.ok) return { success: false, message: result.error };
-      return {
-        success: true,
-        message: `Task "${result.task.title}" updated (${result.task.scheduleText || result.task.schedule}). Changed: ${describeTaskPatch(result.task, result.patch)}`,
-      };
-    }
-  }));
-
-  ctx.tools.register(defineTool({
-    name: 'cron_run_task',
-    description: 'Trigger a task immediately, out of band',
-    parameters: {
-      id: { type: 'string', description: 'Task identifier', required: true }
-    },
-    output: {
-      schema: {
-        type: 'object',
-        additionalProperties: true,
-        properties: {
-          success: { type: 'boolean' },
-          message: { type: 'string' }
-        }
-      },
-      render: (_args, val) => [{ type: 'text', text: val.message }]
-    },
-    execute: async (args) => {
-      const task = store.get(args.id);
-      if (!task) return { success: false, message: 'Task not found' };
-      scheduler.triggerManualRun(args.id);
-      return { success: true, message: `Manual run started for task "${task.title}"` };
-    }
+    name: 'cron',
+    description: 'Background automation runner for DSH: isolated agent runs, script/node/python/http/ssh/docker runtimes, cost guard, notifications, heartbeats. For simple reminders in the current chat, use the built-in schedule_create tool instead. Actions: create, list, get, update, pause, resume, run, delete.',
+    parameters: cronToolParameters,
+    output: cronToolOutput,
+    execute: async (args) => executeCronTool(store, scheduler, args),
   }));
 }

package/lib/prompt.js

@@ -12,9 +12,11 @@ The user's original request:
 "${text}"
 
 CRITICAL RULES FOR THE AGENT:
-1. NEVER RUSH:
-   It is STRICTLY FORBIDDEN to call the \`cron_create_task\` (or \`cron_schedule_task\`) tool in your first reply!
-   You MUST NOT create the task until you have asked clarifying questions and received the user's confirmation.
+1. EVALUATE SIMPLE IN-CHAT REMINDER VS BACKGROUND AUTOMATION:
+   - If the user simply wants a reminder or alert delivered into the current conversation (e.g. "remind me in 2 hours", "say good morning at 9am here"), suggest using the core built-in \`schedule_create\` tool instead.
+   - Use the \`cron\` tool for background automation running in separate isolated sessions, shell/python/node/http/ssh/docker runtimes, multi-channel alerts (Telegram, Discord, Slack, etc.), or monitoring.
+   - NEVER RUSH: It is STRICTLY FORBIDDEN to call the \`cron\` tool in your first reply!
+     You MUST NOT create the task until you have asked clarifying questions and received the user's confirmation.
 
 2. FIRST QUESTION: LLM vs NO-LLM Shell (critical):
    - Evaluate the nature of the task:
@@ -46,7 +48,8 @@ CRITICAL RULES FOR THE AGENT:
    - Ask any remaining questions and ask the user to confirm task creation.
 
 5. CREATING THE TASK:
-   Only AFTER the user replies and confirms the parameters, call the \`cron_create_task\` tool with:
+   Only AFTER the user replies and confirms the parameters, call the \`cron\` tool with:
+   - action: "create"
    - title: a clear task name
    - schedule: the agreed cron expression
    - prompt: the final shell command/script path (for type="script") OR detailed instructions including the Silent Rule (for type="llm")

package/lib/task-patch.js

@@ -1,5 +1,5 @@
 /**
- * Partial task updates, shared by the HTTP PATCH route and the cron_update_task
+ * Partial task updates, shared by the HTTP PATCH route and the cron tool (action: 'update')
  * tool (#49).
  *
  * One implementation keeps the whitelist, the type validation, the schedule
@@ -11,7 +11,7 @@
 import { parseScheduleExpression } from './scheduler.js';
 import { normalizeTaskType, CODE_EXECUTING_TYPES } from './runtimes.js';
 import { PATCHABLE_TASK_FIELDS, validateTaskType } from './task-transfer.js';
-import { pickPatchableFields } from './http-utils.js';
+import { pickPatchableFields, restoreTaskSecrets } from './http-utils.js';
 import { unknownChannelIds } from './channels.js';
 import { isConfigOwned, configOwnedMessage } from './config-jobs.js';
 
@@ -28,7 +28,8 @@ export function isCodeTypeSwitch(current, nextType) {
  * Returns `{ ok: false, error }` when the merged task would be invalid.
  */
 export function buildTaskPatch(current, body) {
-  const patch = pickPatchableFields(body || {}, PATCHABLE_TASK_FIELDS);
+  const mergedBody = current ? restoreTaskSecrets(body || {}, current) : (body || {});
+  const patch = pickPatchableFields(mergedBody, PATCHABLE_TASK_FIELDS);
   if (patch.type !== undefined) {
     patch.type = normalizeTaskType(patch.type);
     const typeError = validateTaskType(patch.type, { ...current, ...patch });

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@goodandready/dsh-cron",
-  "version": "0.2.27",
-  "description": "Scheduled cron tasks, background automation and agent execution for DeepSeek Harness.",
+  "version": "0.2.29",
+  "description": "Background automation runner for DSH: isolated agent runs, script/HTTP/SSH/Docker runtimes, cost guard, notifications, heartbeats.",
   "type": "module",
   "main": "lib/index.js",
   "exports": {