@goodandready/dsh-cron 0.3.34 → 0.3.36
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/README.md +18 -0
- package/README.ru.md +18 -0
- package/README.zh.md +17 -0
- package/lib/client-src/10-locales.js +3 -1
- package/lib/client-src/60-modal-task-form-head.js +2 -1
- package/lib/client.js +5 -2
- package/lib/cron-as-code.js +224 -0
- package/lib/digest.js +179 -0
- package/lib/locales.json +2 -1
- package/lib/routes/routes.js +35 -0
- package/lib/runtimes/runtimes.js +1 -1
- package/lib/scheduler/scheduler-preflight.js +15 -0
- package/lib/scheduler/scheduler.js +12 -0
- package/lib/store/task-schema.js +2 -0
- package/lib/store/task-transfer.js +2 -0
- package/package.json +1 -1
package/README.md
CHANGED
|
@@ -705,3 +705,21 @@ Context is automatically injected into prompts (`{{trigger.type}}`, `{{trigger.f
|
|
|
705
705
|
- **Time-Boxing (`timeBoxMinutes`)**: Set a maximum wall-clock execution limit per run. When exceeded, the agent turn aborts gracefully.
|
|
706
706
|
- **Work Windows (`workWindow`)**: Restrict resource-intensive tasks to run only within specific hours (e.g., `22:00-07:00`) or days.
|
|
707
707
|
- **Outside Policy**: Choose to either `skip` runs outside the window or `defer` execution until the window opens.
|
|
708
|
+
|
|
709
|
+
### Daily & Morning Digest (v0.3.35)
|
|
710
|
+
|
|
711
|
+
- **Dedicated Digest Tasks (`type: "digest"`)**: Schedule consolidated summary reports (e.g., daily at 09:00 AM) that aggregate runs, errors, token usage, and cost across all tasks.
|
|
712
|
+
- **REST API**: Inspect digests on-demand via `GET /dsh-cron/digest` or trigger delivery via `POST /dsh-cron/digest/send`.
|
|
713
|
+
- **Channel Routing**: Automatically delivers formatted summaries to Telegram, Feishu, or webhook channels.
|
|
714
|
+
|
|
715
|
+
### Cron-as-Code (`.dsh/cron.yaml`)
|
|
716
|
+
Declare recurring tasks directly in your repository. `dsh-cron` automatically detects and synchronizes `.dsh/cron.yaml`, `.dsh/cron.yml`, or `.dsh/cron.json`:
|
|
717
|
+
```yaml
|
|
718
|
+
tasks:
|
|
719
|
+
- id: nightly-audit
|
|
720
|
+
title: Nightly Security Audit
|
|
721
|
+
schedule: "0 2 * * *"
|
|
722
|
+
command: npm audit
|
|
723
|
+
timeBoxMinutes: 15
|
|
724
|
+
```
|
|
725
|
+
Git-managed tasks are isolated with zero interference to manual GUI tasks.
|
package/README.ru.md
CHANGED
|
@@ -659,3 +659,21 @@ MIT © [GooDAnDReaDY](https://github.com/GooDAnDReaDY)
|
|
|
659
659
|
- **Time-Boxing (`timeBoxMinutes`)**: Лимит общего времени выполнения задачи в минутах с мягким прерыванием по таймауту.
|
|
660
660
|
- **Окна работы (`workWindow`)**: Запуск тяжелых задач только в разрешенные часы (например, `22:00-07:00`) или дни недели.
|
|
661
661
|
- **Политика вне окна (`outsidePolicy`)**: `skip` (пропуск с записью статуса) или `defer` (откладывание до открытия окна).
|
|
662
|
+
|
|
663
|
+
### Ежедневный дайджест и сводные отчеты (v0.3.35)
|
|
664
|
+
|
|
665
|
+
- **Тип задачи `type: "digest"`**: Настройка периодических отчетов (например, каждое утро в 09:00), агрегирующих количество запусков, сбои, токены и затраты в USD.
|
|
666
|
+
- **REST API**: Эндпоинты `GET /dsh-cron/digest` для просмотра статистики и `POST /dsh-cron/digest/send` для отправки в каналы.
|
|
667
|
+
- **Интеграция с каналами**: Доставка форматированного отчета в Telegram, Feishu или вебхуки.
|
|
668
|
+
|
|
669
|
+
### Cron-as-Code (`.dsh/cron.yaml`)
|
|
670
|
+
Декларируйте расписания задач прямо в репозитории проекта. `dsh-cron` автоматически обнаруживает и синхронизирует конфигурацию из `.dsh/cron.yaml`, `.dsh/cron.yml` или `.dsh/cron.json`:
|
|
671
|
+
```yaml
|
|
672
|
+
tasks:
|
|
673
|
+
- id: nightly-audit
|
|
674
|
+
title: Ночной аудит безопасности
|
|
675
|
+
schedule: "0 2 * * *"
|
|
676
|
+
command: npm audit
|
|
677
|
+
timeBoxMinutes: 15
|
|
678
|
+
```
|
|
679
|
+
Задачи из репозитория изолированы и не перезаписывают ручные задачи, созданные в UI.
|
package/README.zh.md
CHANGED
|
@@ -653,3 +653,20 @@ MIT © [GooDAnDReaDY](https://github.com/GooDAnDReaDY)
|
|
|
653
653
|
- **Time-Boxing (`timeBoxMinutes`)**: 设置单次执行的最长分钟上限,超时时通过 AbortSignal 优雅中止。
|
|
654
654
|
- **时间窗口 (`workWindow`)**: 限制高负载任务仅在指定时段(如 `22:00-07:00`)或特定星期内运行。
|
|
655
655
|
- **窗口外策略 (`outsidePolicy`)**: 支持 `skip`(跳过本次运行)或 `defer`(推迟到窗口开启时自动执行)。
|
|
656
|
+
|
|
657
|
+
### 每日/定期简报与成本汇总 (v0.3.35)
|
|
658
|
+
|
|
659
|
+
- **简报专用任务类型 (`type: "digest"`)**: 可定时调度汇总报告(如每日早晨 09:00),聚合所有任务的运行状态、失败诊断、Token 消耗与估算成本。
|
|
660
|
+
- **REST API**: 支持 `GET /dsh-cron/digest` 查询统计报告,以及 `POST /dsh-cron/digest/send` 主动推送到各通知渠道。
|
|
661
|
+
|
|
662
|
+
### 代码化 Cron(`.dsh/cron.yaml`)
|
|
663
|
+
直接在项目仓库中声明定时任务。`dsh-cron` 自动发现并同步 `.dsh/cron.yaml`、`.dsh/cron.yml` 或 `.dsh/cron.json`:
|
|
664
|
+
```yaml
|
|
665
|
+
tasks:
|
|
666
|
+
- id: nightly-audit
|
|
667
|
+
title: 每夜安全检查
|
|
668
|
+
schedule: "0 2 * * *"
|
|
669
|
+
command: npm audit
|
|
670
|
+
timeBoxMinutes: 15
|
|
671
|
+
```
|
|
672
|
+
Git 管理的任务具有隔离标识,绝不影响或覆盖 UI 手动创建的任务。
|
|
@@ -68,6 +68,7 @@
|
|
|
68
68
|
'form.typePython': 'Python', 'form.typeHttp': 'HTTP request / webhook',
|
|
69
69
|
'form.typeSsh': 'Remote SSH', 'form.typeDocker': 'Docker container',
|
|
70
70
|
'form.typeSkill': 'DSH Skill', 'form.typeWorkflow': 'DSH Workflow',
|
|
71
|
+
'form.typeDigest': 'Daily / Periodic Digest',
|
|
71
72
|
'form.envLabel': 'Environment variables (KEY=VALUE per line)',
|
|
72
73
|
'form.envPlaceholder': 'NODE_ENV=production\nTZ=Europe/Berlin',
|
|
73
74
|
'form.envHint': 'Applied to non-LLM runtimes only. Do not store secrets here.',
|
|
@@ -345,7 +346,8 @@
|
|
|
345
346
|
'form.typeNode': 'Node.js', 'form.typePython': 'Python',
|
|
346
347
|
'form.typeHttp': 'HTTP 请求 / Webhook', 'form.typeSsh': '远程 SSH',
|
|
347
348
|
'form.typeDocker': 'Docker 容器', 'form.typeSkill': 'DSH 技能',
|
|
348
|
-
'form.typeWorkflow': 'DSH 工作流',
|
|
349
|
+
'form.typeWorkflow': 'DSH 工作流',
|
|
350
|
+
'form.typeDigest': '每日/定期简报 (Daily Digest)', 'form.envLabel': '环境变量 (KEY=VALUE, 每行一个)',
|
|
349
351
|
'form.envPlaceholder': 'NODE_ENV=production\nTZ=Europe/Berlin', 'form.envHint': '仅对非 LLM 运行时生效。不要在这里存放密钥。',
|
|
350
352
|
'form.cwdLabel': '工作目录 (绝对路径)', 'form.workspaceLabel': '工作区 ID 或路径(可选)',
|
|
351
353
|
'form.worktreeLabel': '在独立的临时 Git Worktree 中执行', 'form.keepWorktreeLabel': '执行结束后保留 Git Worktree (不自动清理)',
|
|
@@ -313,7 +313,8 @@
|
|
|
313
313
|
React.createElement('option', { value: 'ssh' }, T_KEY(t, 'form.typeSsh')),
|
|
314
314
|
React.createElement('option', { value: 'docker' }, T_KEY(t, 'form.typeDocker')),
|
|
315
315
|
React.createElement('option', { value: 'skill' }, T_KEY(t, 'form.typeSkill')),
|
|
316
|
-
React.createElement('option', { value: 'workflow' }, T_KEY(t, 'form.typeWorkflow'))
|
|
316
|
+
React.createElement('option', { value: 'workflow' }, T_KEY(t, 'form.typeWorkflow')),
|
|
317
|
+
React.createElement('option', { value: 'digest' }, T_KEY(t, 'form.typeDigest'))
|
|
317
318
|
)
|
|
318
319
|
),
|
|
319
320
|
React.createElement('div', { className: 'dsh-cron-form-group' },
|
package/lib/client.js
CHANGED
|
@@ -114,6 +114,7 @@ en: {
|
|
|
114
114
|
'form.typePython': 'Python', 'form.typeHttp': 'HTTP request / webhook',
|
|
115
115
|
'form.typeSsh': 'Remote SSH', 'form.typeDocker': 'Docker container',
|
|
116
116
|
'form.typeSkill': 'DSH Skill', 'form.typeWorkflow': 'DSH Workflow',
|
|
117
|
+
'form.typeDigest': 'Daily / Periodic Digest',
|
|
117
118
|
'form.envLabel': 'Environment variables (KEY=VALUE per line)',
|
|
118
119
|
'form.envPlaceholder': 'NODE_ENV=production\nTZ=Europe/Berlin',
|
|
119
120
|
'form.envHint': 'Applied to non-LLM runtimes only. Do not store secrets here.',
|
|
@@ -390,7 +391,8 @@ zh: {
|
|
|
390
391
|
'form.typeNode': 'Node.js', 'form.typePython': 'Python',
|
|
391
392
|
'form.typeHttp': 'HTTP 请求 / Webhook', 'form.typeSsh': '远程 SSH',
|
|
392
393
|
'form.typeDocker': 'Docker 容器', 'form.typeSkill': 'DSH 技能',
|
|
393
|
-
'form.typeWorkflow': 'DSH 工作流',
|
|
394
|
+
'form.typeWorkflow': 'DSH 工作流',
|
|
395
|
+
'form.typeDigest': '每日/定期简报 (Daily Digest)', 'form.envLabel': '环境变量 (KEY=VALUE, 每行一个)',
|
|
394
396
|
'form.envPlaceholder': 'NODE_ENV=production\nTZ=Europe/Berlin', 'form.envHint': '仅对非 LLM 运行时生效。不要在这里存放密钥。',
|
|
395
397
|
'form.cwdLabel': '工作目录 (绝对路径)', 'form.workspaceLabel': '工作区 ID 或路径(可选)',
|
|
396
398
|
'form.worktreeLabel': '在独立的临时 Git Worktree 中执行', 'form.keepWorktreeLabel': '执行结束后保留 Git Worktree (不自动清理)',
|
|
@@ -3660,7 +3662,8 @@ _h('option', { value: 'http' }, T_KEY(t, 'form.typeHttp')),
|
|
|
3660
3662
|
_h('option', { value: 'ssh' }, T_KEY(t, 'form.typeSsh')),
|
|
3661
3663
|
_h('option', { value: 'docker' }, T_KEY(t, 'form.typeDocker')),
|
|
3662
3664
|
_h('option', { value: 'skill' }, T_KEY(t, 'form.typeSkill')),
|
|
3663
|
-
_h('option', { value: 'workflow' }, T_KEY(t, 'form.typeWorkflow'))
|
|
3665
|
+
_h('option', { value: 'workflow' }, T_KEY(t, 'form.typeWorkflow')),
|
|
3666
|
+
_h('option', { value: 'digest' }, T_KEY(t, 'form.typeDigest'))
|
|
3664
3667
|
)
|
|
3665
3668
|
),
|
|
3666
3669
|
_h('div', { className: 'dsh-cron-form-group' },
|
|
@@ -0,0 +1,224 @@
|
|
|
1
|
+
import fs from 'node:fs';
|
|
2
|
+
import path from 'node:path';
|
|
3
|
+
import { logger } from './logger.js';
|
|
4
|
+
import { bestEffort } from './best-effort.js';
|
|
5
|
+
|
|
6
|
+
/**
|
|
7
|
+
* Lightweight, robust parser for .dsh/cron.yaml, .dsh/cron.yml, and .dsh/cron.json files (#416).
|
|
8
|
+
* Handles JSON and standard task list YAML without external dependencies.
|
|
9
|
+
*/
|
|
10
|
+
export function parseCronAsCode(rawContent) {
|
|
11
|
+
if (!rawContent || typeof rawContent !== 'string') return { tasks: [] };
|
|
12
|
+
const trimmed = rawContent.trim();
|
|
13
|
+
if (!trimmed) return { tasks: [] };
|
|
14
|
+
|
|
15
|
+
// 1. Try standard JSON first
|
|
16
|
+
if (trimmed.startsWith('{') || trimmed.startsWith('[')) {
|
|
17
|
+
try {
|
|
18
|
+
const parsed = JSON.parse(trimmed);
|
|
19
|
+
if (Array.isArray(parsed)) return { tasks: parsed };
|
|
20
|
+
if (parsed && Array.isArray(parsed.tasks)) return parsed;
|
|
21
|
+
return { tasks: [] };
|
|
22
|
+
} catch (_err) {
|
|
23
|
+
void _err;
|
|
24
|
+
}
|
|
25
|
+
}
|
|
26
|
+
|
|
27
|
+
// 2. Simple, resilient YAML parser for task documents
|
|
28
|
+
const lines = trimmed.split(/\r?\n/);
|
|
29
|
+
const tasks = [];
|
|
30
|
+
let currentTask = null;
|
|
31
|
+
let inTasksSection = false;
|
|
32
|
+
|
|
33
|
+
for (const rawLine of lines) {
|
|
34
|
+
const line = rawLine.replace(/#.*$/, '').trimEnd();
|
|
35
|
+
if (!line.trim()) continue;
|
|
36
|
+
|
|
37
|
+
if (line.match(/^tasks\s*:/i)) {
|
|
38
|
+
inTasksSection = true;
|
|
39
|
+
continue;
|
|
40
|
+
}
|
|
41
|
+
|
|
42
|
+
const itemMatch = line.match(/^(\s*)-\s+(.*)$/);
|
|
43
|
+
if (itemMatch) {
|
|
44
|
+
if (currentTask) tasks.push(currentTask);
|
|
45
|
+
currentTask = {};
|
|
46
|
+
const rest = itemMatch[2].trim();
|
|
47
|
+
if (rest) {
|
|
48
|
+
const kv = parseYamlKeyValue(rest);
|
|
49
|
+
if (kv) currentTask[kv.key] = kv.value;
|
|
50
|
+
}
|
|
51
|
+
continue;
|
|
52
|
+
}
|
|
53
|
+
|
|
54
|
+
if (currentTask) {
|
|
55
|
+
const kv = parseYamlKeyValue(line.trim());
|
|
56
|
+
if (kv) {
|
|
57
|
+
currentTask[kv.key] = kv.value;
|
|
58
|
+
}
|
|
59
|
+
}
|
|
60
|
+
}
|
|
61
|
+
|
|
62
|
+
if (currentTask) tasks.push(currentTask);
|
|
63
|
+
return { tasks };
|
|
64
|
+
}
|
|
65
|
+
|
|
66
|
+
function parseYamlKeyValue(line) {
|
|
67
|
+
const match = line.match(/^([a-zA-Z0-9_-]+)\s*:\s*(.*)$/);
|
|
68
|
+
if (!match) return null;
|
|
69
|
+
const key = match[1].trim();
|
|
70
|
+
let valStr = match[2].trim();
|
|
71
|
+
|
|
72
|
+
// Strip wrapping quotes
|
|
73
|
+
if ((valStr.startsWith('"') && valStr.endsWith('"')) || (valStr.startsWith("'") && valStr.endsWith("'"))) {
|
|
74
|
+
valStr = valStr.slice(1, -1);
|
|
75
|
+
return { key, value: valStr };
|
|
76
|
+
}
|
|
77
|
+
|
|
78
|
+
if (valStr.toLowerCase() === 'true') return { key, value: true };
|
|
79
|
+
if (valStr.toLowerCase() === 'false') return { key, value: false };
|
|
80
|
+
if (/^-?\d+$/.test(valStr)) return { key, value: parseInt(valStr, 10) };
|
|
81
|
+
if (/^-?\d+\.\d+$/.test(valStr)) return { key, value: parseFloat(valStr) };
|
|
82
|
+
|
|
83
|
+
return { key, value: valStr };
|
|
84
|
+
}
|
|
85
|
+
|
|
86
|
+
/**
|
|
87
|
+
* Reconciles tasks declared in a workspace with the store (#416).
|
|
88
|
+
*/
|
|
89
|
+
export function reconcileWorkspaceCronTasks(store, workspaceId, declaredTasks = []) {
|
|
90
|
+
if (!store || !workspaceId) return { created: 0, updated: 0, deleted: 0 };
|
|
91
|
+
|
|
92
|
+
const currentTasks = store.list ? store.list() : (store.tasks ? Object.values(store.tasks) : []);
|
|
93
|
+
const existingManaged = new Map();
|
|
94
|
+
|
|
95
|
+
for (const t of currentTasks) {
|
|
96
|
+
if (t && t.workspaceId === workspaceId && t.managedBy === 'cron_as_code') {
|
|
97
|
+
existingManaged.set(t.id, t);
|
|
98
|
+
}
|
|
99
|
+
}
|
|
100
|
+
|
|
101
|
+
let created = 0;
|
|
102
|
+
let updated = 0;
|
|
103
|
+
let deleted = 0;
|
|
104
|
+
const seenIds = new Set();
|
|
105
|
+
|
|
106
|
+
for (const decl of declaredTasks) {
|
|
107
|
+
if (!decl || typeof decl !== 'object') continue;
|
|
108
|
+
const rawId = decl.id || decl.name || Math.random().toString(36).slice(2, 9);
|
|
109
|
+
const taskId = `cac_${workspaceId}_${rawId}`.replace(/[^a-zA-Z0-9_-]/g, '_');
|
|
110
|
+
seenIds.add(taskId);
|
|
111
|
+
|
|
112
|
+
const taskRecord = {
|
|
113
|
+
...decl,
|
|
114
|
+
id: taskId,
|
|
115
|
+
title: decl.title || decl.name || rawId,
|
|
116
|
+
schedule: decl.schedule || '0 0 * * *',
|
|
117
|
+
status: decl.status || 'active',
|
|
118
|
+
workspaceId,
|
|
119
|
+
managedBy: 'cron_as_code',
|
|
120
|
+
origin: '.dsh/cron.yaml',
|
|
121
|
+
type: decl.type || 'script',
|
|
122
|
+
};
|
|
123
|
+
|
|
124
|
+
if (existingManaged.has(taskId)) {
|
|
125
|
+
const existing = existingManaged.get(taskId);
|
|
126
|
+
store.set({ ...existing, ...taskRecord });
|
|
127
|
+
updated++;
|
|
128
|
+
} else {
|
|
129
|
+
store.set(taskRecord);
|
|
130
|
+
created++;
|
|
131
|
+
}
|
|
132
|
+
}
|
|
133
|
+
|
|
134
|
+
// Delete tasks removed from declaration
|
|
135
|
+
for (const [id, oldTask] of existingManaged.entries()) {
|
|
136
|
+
if (!seenIds.has(id)) {
|
|
137
|
+
if (typeof store.delete === 'function') {
|
|
138
|
+
store.delete(id);
|
|
139
|
+
} else {
|
|
140
|
+
oldTask.status = 'completed';
|
|
141
|
+
store.set(oldTask);
|
|
142
|
+
}
|
|
143
|
+
deleted++;
|
|
144
|
+
}
|
|
145
|
+
}
|
|
146
|
+
|
|
147
|
+
return { created, updated, deleted };
|
|
148
|
+
}
|
|
149
|
+
|
|
150
|
+
/**
|
|
151
|
+
* CronAsCodeManager observes workspace directories and auto-synchronizes .dsh/cron.yaml files (#416).
|
|
152
|
+
*/
|
|
153
|
+
export class CronAsCodeManager {
|
|
154
|
+
constructor(scheduler) {
|
|
155
|
+
this.scheduler = scheduler;
|
|
156
|
+
this.watchers = new Map(); // workspaceId -> { watcher, filePath }
|
|
157
|
+
}
|
|
158
|
+
|
|
159
|
+
findConfigFile(workspaceDir) {
|
|
160
|
+
if (!workspaceDir || typeof workspaceDir !== 'string') return null;
|
|
161
|
+
const candidates = [
|
|
162
|
+
path.join(workspaceDir, '.dsh', 'cron.yaml'),
|
|
163
|
+
path.join(workspaceDir, '.dsh', 'cron.yml'),
|
|
164
|
+
path.join(workspaceDir, '.dsh', 'cron.json'),
|
|
165
|
+
];
|
|
166
|
+
for (const c of candidates) {
|
|
167
|
+
if (fs.existsSync(c)) return c;
|
|
168
|
+
}
|
|
169
|
+
return null;
|
|
170
|
+
}
|
|
171
|
+
|
|
172
|
+
syncWorkspace(workspaceId, workspaceDir) {
|
|
173
|
+
if (!workspaceId || !workspaceDir || !this.scheduler) return null;
|
|
174
|
+
const filePath = this.findConfigFile(workspaceDir);
|
|
175
|
+
|
|
176
|
+
if (!filePath) {
|
|
177
|
+
this.unwatchWorkspace(workspaceId);
|
|
178
|
+
return null;
|
|
179
|
+
}
|
|
180
|
+
|
|
181
|
+
try {
|
|
182
|
+
const content = fs.readFileSync(filePath, 'utf8');
|
|
183
|
+
const { tasks } = parseCronAsCode(content);
|
|
184
|
+
const res = reconcileWorkspaceCronTasks(this.scheduler.store, workspaceId, tasks);
|
|
185
|
+
logger.info(`[dsh-cron] Cron-as-Code synchronized "${filePath}" for workspace ${workspaceId}: +${res.created} ~${res.updated} -${res.deleted}`);
|
|
186
|
+
|
|
187
|
+
// Arm watcher if not already watching this file
|
|
188
|
+
const current = this.watchers.get(workspaceId);
|
|
189
|
+
if (!current || current.filePath !== filePath) {
|
|
190
|
+
this.unwatchWorkspace(workspaceId);
|
|
191
|
+
try {
|
|
192
|
+
const watcher = fs.watch(filePath, (event) => {
|
|
193
|
+
if (event === 'change') {
|
|
194
|
+
this.syncWorkspace(workspaceId, workspaceDir);
|
|
195
|
+
}
|
|
196
|
+
});
|
|
197
|
+
this.watchers.set(workspaceId, { watcher, filePath });
|
|
198
|
+
} catch (_err) {
|
|
199
|
+
void _err;
|
|
200
|
+
}
|
|
201
|
+
}
|
|
202
|
+
|
|
203
|
+
return res;
|
|
204
|
+
} catch (err) {
|
|
205
|
+
logger.error(`[dsh-cron] Failed to read Cron-as-Code file "${filePath}": ${err.message}`);
|
|
206
|
+
return null;
|
|
207
|
+
}
|
|
208
|
+
}
|
|
209
|
+
|
|
210
|
+
unwatchWorkspace(workspaceId) {
|
|
211
|
+
const entry = this.watchers.get(workspaceId);
|
|
212
|
+
if (entry && entry.watcher) {
|
|
213
|
+
bestEffort('cron-as-code-unwatch', () => entry.watcher.close());
|
|
214
|
+
this.watchers.delete(workspaceId);
|
|
215
|
+
}
|
|
216
|
+
}
|
|
217
|
+
|
|
218
|
+
stopAll() {
|
|
219
|
+
for (const entry of this.watchers.values()) {
|
|
220
|
+
bestEffort('cron-as-code-stop', () => entry.watcher.close());
|
|
221
|
+
}
|
|
222
|
+
this.watchers.clear();
|
|
223
|
+
}
|
|
224
|
+
}
|
package/lib/digest.js
ADDED
|
@@ -0,0 +1,179 @@
|
|
|
1
|
+
import { logger } from './logger.js';
|
|
2
|
+
import { sendTelegramMessage } from './telegram.js';
|
|
3
|
+
import { bestEffort } from './best-effort.js';
|
|
4
|
+
|
|
5
|
+
/**
|
|
6
|
+
* Aggregates execution metrics over a rolling time window (#414).
|
|
7
|
+
*/
|
|
8
|
+
export function collectDigestMetrics(store, options = {}) {
|
|
9
|
+
const windowMs = Number(options.windowMs) > 0 ? Number(options.windowMs) : 86400000;
|
|
10
|
+
const since = Date.now() - windowMs;
|
|
11
|
+
|
|
12
|
+
const tasksMap = new Map();
|
|
13
|
+
if (store && store.tasks) {
|
|
14
|
+
const list = Array.isArray(store.tasks)
|
|
15
|
+
? store.tasks
|
|
16
|
+
: (typeof store.tasks.values === 'function' ? Array.from(store.tasks.values()) : Object.values(store.tasks));
|
|
17
|
+
for (const t of list) {
|
|
18
|
+
if (t && t.id) tasksMap.set(t.id, t);
|
|
19
|
+
}
|
|
20
|
+
}
|
|
21
|
+
|
|
22
|
+
let totalRuns = 0;
|
|
23
|
+
let successRuns = 0;
|
|
24
|
+
let failedRuns = 0;
|
|
25
|
+
let skippedRuns = 0;
|
|
26
|
+
let inputTokens = 0;
|
|
27
|
+
let outputTokens = 0;
|
|
28
|
+
let cacheReadTokens = 0;
|
|
29
|
+
let totalCostUsd = 0;
|
|
30
|
+
|
|
31
|
+
const failures = [];
|
|
32
|
+
const perTask = new Map();
|
|
33
|
+
|
|
34
|
+
let allRunArrays = [];
|
|
35
|
+
if (store && store.history) {
|
|
36
|
+
if (typeof store.history.values === 'function') {
|
|
37
|
+
allRunArrays = Array.from(store.history.values());
|
|
38
|
+
} else if (typeof store.history === 'object') {
|
|
39
|
+
allRunArrays = Object.values(store.history);
|
|
40
|
+
}
|
|
41
|
+
}
|
|
42
|
+
|
|
43
|
+
for (const runs of allRunArrays) {
|
|
44
|
+
if (!Array.isArray(runs)) continue;
|
|
45
|
+
for (const run of runs) {
|
|
46
|
+
if (!run) continue;
|
|
47
|
+
const ts = run.finishedAt || run.startedAt || 0;
|
|
48
|
+
if (ts < since) continue;
|
|
49
|
+
|
|
50
|
+
totalRuns++;
|
|
51
|
+
const isSuccess = run.status === 'success' || run.status === 'completed';
|
|
52
|
+
const isFailed = run.status === 'error' || run.status === 'timeout' || run.status === 'failed';
|
|
53
|
+
const isSkipped = run.status === 'skipped';
|
|
54
|
+
|
|
55
|
+
if (isSuccess) successRuns++;
|
|
56
|
+
else if (isFailed) failedRuns++;
|
|
57
|
+
else if (isSkipped) skippedRuns++;
|
|
58
|
+
|
|
59
|
+
const u = run.usage || {};
|
|
60
|
+
const runIn = Number(u.inputTokens) || 0;
|
|
61
|
+
const runOut = Number(u.outputTokens) || 0;
|
|
62
|
+
const runCache = Number(u.cacheReadTokens) || 0;
|
|
63
|
+
const runCost = Number(run.costUsd) || 0;
|
|
64
|
+
|
|
65
|
+
inputTokens += runIn;
|
|
66
|
+
outputTokens += runOut;
|
|
67
|
+
cacheReadTokens += runCache;
|
|
68
|
+
totalCostUsd += runCost;
|
|
69
|
+
|
|
70
|
+
const taskId = run.taskId || 'unknown';
|
|
71
|
+
const taskObj = tasksMap.get(taskId);
|
|
72
|
+
const title = (taskObj && taskObj.title) || run.taskTitle || taskId;
|
|
73
|
+
|
|
74
|
+
if (isFailed) {
|
|
75
|
+
failures.push({
|
|
76
|
+
taskId,
|
|
77
|
+
title,
|
|
78
|
+
status: run.status,
|
|
79
|
+
error: run.error || 'Unknown error',
|
|
80
|
+
diagnosis: run.diagnosis || null,
|
|
81
|
+
finishedAt: ts,
|
|
82
|
+
});
|
|
83
|
+
}
|
|
84
|
+
|
|
85
|
+
if (!perTask.has(taskId)) {
|
|
86
|
+
perTask.set(taskId, {
|
|
87
|
+
id: taskId,
|
|
88
|
+
title,
|
|
89
|
+
total: 0,
|
|
90
|
+
success: 0,
|
|
91
|
+
failed: 0,
|
|
92
|
+
skipped: 0,
|
|
93
|
+
costUsd: 0,
|
|
94
|
+
tokens: 0,
|
|
95
|
+
});
|
|
96
|
+
}
|
|
97
|
+
const p = perTask.get(taskId);
|
|
98
|
+
p.total++;
|
|
99
|
+
if (isSuccess) p.success++;
|
|
100
|
+
if (isFailed) p.failed++;
|
|
101
|
+
if (isSkipped) p.skipped++;
|
|
102
|
+
p.costUsd += runCost;
|
|
103
|
+
p.tokens += (runIn + runOut);
|
|
104
|
+
}
|
|
105
|
+
}
|
|
106
|
+
|
|
107
|
+
const taskBreakdown = Array.from(perTask.values()).sort((a, b) => b.costUsd - a.costUsd || b.total - a.total);
|
|
108
|
+
|
|
109
|
+
return {
|
|
110
|
+
windowHours: Math.round(windowMs / 3600000),
|
|
111
|
+
since,
|
|
112
|
+
generatedAt: Date.now(),
|
|
113
|
+
totalRuns,
|
|
114
|
+
successRuns,
|
|
115
|
+
failedRuns,
|
|
116
|
+
skippedRuns,
|
|
117
|
+
totalTokens: inputTokens + outputTokens + cacheReadTokens,
|
|
118
|
+
inputTokens,
|
|
119
|
+
outputTokens,
|
|
120
|
+
cacheReadTokens,
|
|
121
|
+
totalCostUsd: Number(totalCostUsd.toFixed(4)),
|
|
122
|
+
failures: failures.slice(0, 10),
|
|
123
|
+
taskBreakdown,
|
|
124
|
+
};
|
|
125
|
+
}
|
|
126
|
+
|
|
127
|
+
/**
|
|
128
|
+
* Formats digest metrics into standard GitHub-flavored Markdown.
|
|
129
|
+
*/
|
|
130
|
+
export function formatDigestReport(metrics) {
|
|
131
|
+
const hours = metrics.windowHours || 24;
|
|
132
|
+
let md = `📊 **DSH-Cron Daily Digest** (Past ${hours} Hours)\n`;
|
|
133
|
+
md += `──────────────────────────────\n`;
|
|
134
|
+
md += `• **Total Runs**: ${metrics.totalRuns} (✅ ${metrics.successRuns} success, ❌ ${metrics.failedRuns} failed, ⏭️ ${metrics.skippedRuns} skipped)\n`;
|
|
135
|
+
md += `• **Estimated Cost**: $${metrics.totalCostUsd.toFixed(4)} USD\n`;
|
|
136
|
+
md += `• **Tokens**: ${metrics.totalTokens.toLocaleString()} (${metrics.inputTokens.toLocaleString()} in, ${metrics.outputTokens.toLocaleString()} out)\n`;
|
|
137
|
+
|
|
138
|
+
if (metrics.failures.length > 0) {
|
|
139
|
+
md += `\n⚠️ **Failures & Alerts (${metrics.failures.length})**:\n`;
|
|
140
|
+
for (const f of metrics.failures) {
|
|
141
|
+
const diag = f.diagnosis ? ` (${f.diagnosis})` : '';
|
|
142
|
+
md += `- **${f.title}**: ${f.error}${diag}\n`;
|
|
143
|
+
}
|
|
144
|
+
}
|
|
145
|
+
|
|
146
|
+
if (metrics.taskBreakdown.length > 0) {
|
|
147
|
+
md += `\n📈 **Top Tasks by Activity / Spend**:\n`;
|
|
148
|
+
for (const t of metrics.taskBreakdown.slice(0, 5)) {
|
|
149
|
+
md += `- **${t.title}**: ${t.total} runs (✅ ${t.success}, ❌ ${t.failed}), $${t.costUsd.toFixed(4)}\n`;
|
|
150
|
+
}
|
|
151
|
+
}
|
|
152
|
+
|
|
153
|
+
md += `──────────────────────────────\n`;
|
|
154
|
+
return md;
|
|
155
|
+
}
|
|
156
|
+
|
|
157
|
+
/**
|
|
158
|
+
* Sends formatted digest report to notification channels.
|
|
159
|
+
*/
|
|
160
|
+
export async function dispatchDigest(metricsOrText, settings = {}, options = {}) {
|
|
161
|
+
const text = typeof metricsOrText === 'string' ? metricsOrText : formatDigestReport(metricsOrText);
|
|
162
|
+
const channels = options.channels || ['telegram'];
|
|
163
|
+
const results = { delivered: [], failed: [] };
|
|
164
|
+
|
|
165
|
+
if (channels.includes('telegram')) {
|
|
166
|
+
const token = settings.telegramToken || process.env.TELEGRAM_BOT_TOKEN;
|
|
167
|
+
const chatId = settings.telegramChatId || process.env.TELEGRAM_CHAT_ID;
|
|
168
|
+
if (token && chatId) {
|
|
169
|
+
try {
|
|
170
|
+
await sendTelegramMessage(token, chatId, text);
|
|
171
|
+
results.delivered.push('telegram');
|
|
172
|
+
} catch (err) {
|
|
173
|
+
results.failed.push({ channel: 'telegram', error: err.message });
|
|
174
|
+
}
|
|
175
|
+
}
|
|
176
|
+
}
|
|
177
|
+
|
|
178
|
+
return results;
|
|
179
|
+
}
|
package/lib/locales.json
CHANGED
|
@@ -425,6 +425,7 @@
|
|
|
425
425
|
"form.workWindowPolicyLabel": "窗口外执行策略",
|
|
426
426
|
"form.workWindowPolicySkip": "跳过本次执行 (record skipped)",
|
|
427
427
|
"form.workWindowPolicyDefer": "延迟至窗口开启时执行 (defer)",
|
|
428
|
-
"form.timeBoxMinutesLabel": "Timebox 运行上限 (分钟, 0 = 不限制)"
|
|
428
|
+
"form.timeBoxMinutesLabel": "Timebox 运行上限 (分钟, 0 = 不限制)",
|
|
429
|
+
"form.typeDigest": "每日/定期简报 (Daily Digest)"
|
|
429
430
|
}
|
|
430
431
|
}
|
package/lib/routes/routes.js
CHANGED
|
@@ -1,3 +1,4 @@
|
|
|
1
|
+
import { collectDigestMetrics, formatDigestReport, dispatchDigest } from '../digest.js';
|
|
1
2
|
import { readFileSync } from 'node:fs';
|
|
2
3
|
import { handleTaskWebhookRoute } from './api-task-webhook.js';
|
|
3
4
|
import { calculateCostHeatmap } from '../timeline.js';
|
|
@@ -229,6 +230,40 @@ export function registerRoutes(ctx, { store, scheduler, recommendations }) {
|
|
|
229
230
|
}
|
|
230
231
|
}), 'dsh-cron: /chat/start');
|
|
231
232
|
|
|
233
|
+
// GET & POST /dsh-cron/digest (#414)
|
|
234
|
+
ctx.effect(() => ctx.webServer.register({
|
|
235
|
+
kind: 'prefix',
|
|
236
|
+
path: '/dsh-cron/digest',
|
|
237
|
+
handler: async (req, res) => {
|
|
238
|
+
try {
|
|
239
|
+
const settings = store && typeof store.getSettings === 'function' ? store.getSettings() : {};
|
|
240
|
+
const apiToken = settings.apiToken;
|
|
241
|
+
if (rejectCrossOrigin(req, res, { apiToken, ctx })) return;
|
|
242
|
+
|
|
243
|
+
const url = new URL(req.url, 'http://127.0.0.1');
|
|
244
|
+
const hours = Number(url.searchParams.get('hours')) || 24;
|
|
245
|
+
const metrics = collectDigestMetrics(store, { windowMs: hours * 3600000 });
|
|
246
|
+
const report = formatDigestReport(metrics);
|
|
247
|
+
|
|
248
|
+
if (req.method === 'GET') {
|
|
249
|
+
sendJson(res, 200, { ok: true, metrics, report });
|
|
250
|
+
return;
|
|
251
|
+
}
|
|
252
|
+
|
|
253
|
+
if (req.method === 'POST') {
|
|
254
|
+
const results = await dispatchDigest(report, settings);
|
|
255
|
+
sendJson(res, 200, { ok: true, report, metrics, results });
|
|
256
|
+
return;
|
|
257
|
+
}
|
|
258
|
+
|
|
259
|
+
res.statusCode = 405;
|
|
260
|
+
res.end();
|
|
261
|
+
} catch (err) {
|
|
262
|
+
sendJson(res, 500, { ok: false, error: err.message });
|
|
263
|
+
}
|
|
264
|
+
}
|
|
265
|
+
}), 'dsh-cron: /digest');
|
|
266
|
+
|
|
232
267
|
// Analytics digest routes (#330)
|
|
233
268
|
ctx.effect(() => ctx.webServer.register({
|
|
234
269
|
kind: 'prefix',
|
package/lib/runtimes/runtimes.js
CHANGED
|
@@ -12,7 +12,7 @@ import path from 'node:path';
|
|
|
12
12
|
|
|
13
13
|
export const EXTERNAL_RUNTIMES = ['script', 'node', 'python', 'http', 'ssh', 'docker'];
|
|
14
14
|
const AGENT_RUNTIMES = ['llm', 'skill', 'workflow'];
|
|
15
|
-
export const TASK_TYPES = [...AGENT_RUNTIMES, ...EXTERNAL_RUNTIMES];
|
|
15
|
+
export const TASK_TYPES = [...AGENT_RUNTIMES, ...EXTERNAL_RUNTIMES, 'digest'];
|
|
16
16
|
|
|
17
17
|
/** Types that execute code and therefore need the HTTP confirm header. */
|
|
18
18
|
export const CODE_EXECUTING_TYPES = ['script', 'node', 'python', 'ssh', 'docker'];
|
|
@@ -1,3 +1,4 @@
|
|
|
1
|
+
import { collectDigestMetrics, formatDigestReport } from '../digest.js';
|
|
1
2
|
import { exec } from 'node:child_process';
|
|
2
3
|
import fs from 'node:fs';
|
|
3
4
|
import { executeSwarmTask } from '../swarm.js';
|
|
@@ -127,6 +128,20 @@ export async function executeOnce(scheduler, task, signal, options = {}) {
|
|
|
127
128
|
model: task.model || '',
|
|
128
129
|
fallback: false,
|
|
129
130
|
};
|
|
131
|
+
if (task.type === 'digest') {
|
|
132
|
+
try {
|
|
133
|
+
const windowHours = Number(task.digestHours || task.windowHours) || 24;
|
|
134
|
+
const metrics = collectDigestMetrics(scheduler.store, { windowMs: windowHours * 3600000 });
|
|
135
|
+
const report = formatDigestReport(metrics);
|
|
136
|
+
result.output = report;
|
|
137
|
+
result.status = 'success';
|
|
138
|
+
return result;
|
|
139
|
+
} catch (err) {
|
|
140
|
+
result.error = err.message || String(err);
|
|
141
|
+
result.status = 'error';
|
|
142
|
+
return result;
|
|
143
|
+
}
|
|
144
|
+
}
|
|
130
145
|
if (task.type === 'swarm') {
|
|
131
146
|
try {
|
|
132
147
|
const swarmRes = await executeSwarmTask(task, {
|
|
@@ -5,6 +5,7 @@ import { FileSystemWatcherManager } from '../watcher.js';
|
|
|
5
5
|
import { parseNaturalSchedule } from '../nl-schedule.js';
|
|
6
6
|
import { ScopeLockManager } from '../scope-locks.js';
|
|
7
7
|
import { WakeTriggerManager } from '../wake-triggers.js';
|
|
8
|
+
import { CronAsCodeManager } from '../cron-as-code.js';
|
|
8
9
|
|
|
9
10
|
const MAX_TIMEOUT_MS = 2147483647; // 2^31 - 1 ms (~24.85 days)
|
|
10
11
|
import {
|
|
@@ -342,6 +343,7 @@ export class TaskScheduler {
|
|
|
342
343
|
this.watcherManager = new FileSystemWatcherManager(this);
|
|
343
344
|
this.scopeLocks = new ScopeLockManager();
|
|
344
345
|
this.wakeTriggerManager = new WakeTriggerManager(this);
|
|
346
|
+
this.cronAsCodeManager = new CronAsCodeManager(this);
|
|
345
347
|
this.logger = opts.logger || null;
|
|
346
348
|
this.isStopped = false;
|
|
347
349
|
this.generation = 0;
|
|
@@ -380,6 +382,13 @@ export class TaskScheduler {
|
|
|
380
382
|
this.deferredTimers.set(taskId, timer);
|
|
381
383
|
}
|
|
382
384
|
|
|
385
|
+
syncWorkspaceCronAsCode(workspaceId, workspaceDir) {
|
|
386
|
+
if (this.cronAsCodeManager) {
|
|
387
|
+
return this.cronAsCodeManager.syncWorkspace(workspaceId, workspaceDir);
|
|
388
|
+
}
|
|
389
|
+
return null;
|
|
390
|
+
}
|
|
391
|
+
|
|
383
392
|
clearDeferredTimer(taskId) {
|
|
384
393
|
const t = this.deferredTimers.get(taskId);
|
|
385
394
|
if (t) {
|
|
@@ -511,6 +520,9 @@ export class TaskScheduler {
|
|
|
511
520
|
if (this.wakeTriggerManager) {
|
|
512
521
|
this.wakeTriggerManager.stopAll();
|
|
513
522
|
}
|
|
523
|
+
if (this.cronAsCodeManager) {
|
|
524
|
+
this.cronAsCodeManager.stopAll();
|
|
525
|
+
}
|
|
514
526
|
|
|
515
527
|
// Clear concurrency queue (#217)
|
|
516
528
|
this.queue = [];
|
package/lib/store/task-schema.js
CHANGED
|
@@ -102,6 +102,8 @@ export const TaskSchema = z.object({
|
|
|
102
102
|
wakeTrigger: z.any(),
|
|
103
103
|
workWindow: z.any(),
|
|
104
104
|
timeBoxMinutes: z.number().min(0).default(0),
|
|
105
|
+
managedBy: z.string().default(''),
|
|
106
|
+
origin: z.string().default(''),
|
|
105
107
|
maxMemoryMb: z.number().min(0).default(0),
|
|
106
108
|
executionTimeoutMs: z.number().min(0).default(900000),
|
|
107
109
|
maxLogBytesPerRun: z.number().min(0).default(5 * 1024 * 1024),
|
package/package.json
CHANGED
|
@@ -1,6 +1,6 @@
|
|
|
1
1
|
{
|
|
2
2
|
"name": "@goodandready/dsh-cron",
|
|
3
|
-
"version": "0.3.
|
|
3
|
+
"version": "0.3.36",
|
|
4
4
|
"description": "Background automation runner for DSH: isolated agent runs, script/HTTP/SSH/Docker runtimes, cost guard, notifications, heartbeats.",
|
|
5
5
|
"type": "module",
|
|
6
6
|
"main": "lib/index.js",
|