@goodandready/dsh-cron 0.1.14 → 0.1.16

package/README.md

@@ -108,6 +108,23 @@ When autonomous agents need to set up delayed or recurring actions, they can inv
 * **`cron_list_tasks`**: Retrieves an overview of active schedules and next scheduled run timestamps.
 * **`cron_toggle_task`**: Enables or disables an existing task by `id`.
 
+### 6. Telegram Notifications & Delivery Routing
+Direct integration with the Telegram Bot API delivers execution reports and error traces straight to your messenger:
+
+* **Auto-Detected or Custom Credentials**: Enter a custom `botToken` and `chatId` in the UI settings dialog, or automatically inherit default credentials from `dsh-messenger-gateway` in `settings.yaml`.
+* **'Only on Failure' Mode (Issue #24)**: Prevent notification spam by enabling `onlyOnFailure` globally or on individual tasks. Clean runs remain silent, while non-zero exit codes or agent exceptions immediately dispatch an alert with stdout/stderr traces.
+* **Markdown Formatting**: Messages are formatted with status badges (✅ / ❌), execution duration in milliseconds, schedule descriptions, and monospace code blocks.
+* **Test Dispatch Button**: Verify Telegram connectivity on the spot before scheduling critical production jobs.
+
+### 7. Overlap Policies & Execution Timeout Control (Issues #11, #17)
+Prevent rogue processes from consuming server resources or stacking concurrent duplicate executions:
+
+* **Execution Timeout (`timeoutSeconds`)**: Automatically cancels agent sessions or kills shell subprocesses when the configured run time limit is reached (default: 1800s / 30m). Prevents hung tasks and records a descriptive timeout failure in run logs.
+* **Overlap Policy (`overlapPolicy`)**: Controls scheduler behavior when a scheduled tick fires while the previous execution is still running:
+  * **`skip`** (default): Drops the overlapping run and records a `skipped` status entry in the run history without spamming.
+  * **`queue`**: Queues the next execution and starts it automatically as soon as the active job completes.
+  * **`replace`**: Aborts the stuck/active run immediately via `AbortController` and launches the fresh execution.
+
 ### 5. Schedule Expression Syntax
 Powered by `croner`, supporting both standard 5-part/6-part cron expressions and user-friendly interval aliases:
 

package/lib/client.js

@@ -27,6 +27,8 @@ const React = window.React || require('react');
     const ICON_ACTIVITY = '<svg viewBox="0 0 24 24" width="18" height="18" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><polyline points="22 12 18 12 15 21 9 3 6 12 2 12"></polyline></svg>';
     const ICON_EDIT = '<svg viewBox="0 0 24 24" width="14" height="14" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M11 4H4a2 2 0 0 0-2 2v14a2 2 0 0 0 2 2h14a2 2 0 0 0 2-2v-7"></path><path d="M18.5 2.5a2.121 2.121 0 0 1 3 3L12 15l-4 1 1-4 9.5-9.5z"></path></svg>';
     const ICON_SEND = '<svg viewBox="0 0 24 24" width="16" height="16" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><line x1="22" y1="2" x2="11" y2="13"></line><polygon points="22 2 15 22 11 13 2 9 22 2"></polygon></svg>';
+    const ICON_SETTINGS = '<svg viewBox="0 0 24 24" width="15" height="15" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><circle cx="12" cy="12" r="3"></circle><path d="M19.4 15a1.65 1.65 0 0 0 .33 1.82l.06.06a2 2 0 0 1 0 2.83 2 2 0 0 1-2.83 0l-.06-.06a1.65 1.65 0 0 0-1.82-.33 1.65 1.65 0 0 0-1 1.51V21a2 2 0 0 1-2 2 2 2 0 0 1-2-2v-.09A1.65 1.65 0 0 0 9 19.4a1.65 1.65 0 0 0-1.82.33l-.06.06a2 2 0 0 1-2.83 0 2 2 0 0 1 0-2.83l.06-.06a1.65 1.65 0 0 0 .33-1.82 1.65 1.65 0 0 0-1.51-1H3a2 2 0 0 1-2-2 2 2 0 0 1 2-2h.09A1.65 1.65 0 0 0 4.6 9a1.65 1.65 0 0 0-.33-1.82l-.06-.06a2 2 0 0 1 0-2.83 2 2 0 0 1 2.83 0l.06.06a1.65 1.65 0 0 0 1.82.33H9a1.65 1.65 0 0 0 1-1.51V3a2 2 0 0 1 2-2 2 2 0 0 1 2 2v.09a1.65 1.65 0 0 0 1 1.51 1.65 1.65 0 0 0 1.82-.33l.06-.06a2 2 0 0 1 2.83 0 2 2 0 0 1 0 2.83l-.06.06a1.65 1.65 0 0 0-.33 1.82V9a1.65 1.65 0 0 0 1.51 1H21a2 2 0 0 1 2 2 2 2 0 0 1-2 2h-.09a1.65 1.65 0 0 0-1.51 1z"></path></svg>';
+    const ICON_TELEGRAM = '<svg viewBox="0 0 24 24" width="16" height="16" fill="currentColor"><path d="M12 2C6.48 2 2 6.48 2 12s4.48 10 10 10 10-4.48 10-10S17.52 2 12 2zm4.64 6.8-1.7 8.01c-.13.58-.47.72-.95.45l-2.6-1.92-1.25 1.21c-.14.14-.26.26-.53.26l.19-2.64 4.81-4.35c.21-.19-.05-.29-.32-.11L8.34 13.5 5.78 12.7c-.56-.17-.57-.56.12-.83l10-3.86c.46-.17.87.11.74.79z"/></svg>';
 
     const STYLES = `
       [data-pane=conversation], [class*=centerCol] {
@@ -134,9 +136,17 @@ const React = window.React || require('react');
       .dsh-cron-history-status { font-weight: 600; font-size: 11.5px; text-transform: uppercase; padding: 2px 6px; border-radius: 4px; }
       .dsh-cron-history-status[data-status="success"] { background: rgba(16, 185, 129, 0.15); color: #10b981; }
       .dsh-cron-history-status[data-status="error"] { background: rgba(239, 68, 68, 0.15); color: #ef4444; }
+      .dsh-cron-history-status[data-status="skipped"] { background: rgba(234, 179, 8, 0.15); color: #eab308; }
       .dsh-cron-history-time { color: #777; font-size: 12px; }
       .dsh-cron-history-output { background: #0c0c0c; border: 1px solid #222; border-radius: 6px; padding: 8px 10px; font-family: monospace; font-size: 12px; color: #bbb; max-height: 140px; overflow-y: auto; white-space: pre-wrap; word-break: break-all; margin-top: 6px; }
       .dsh-cron-history-empty { text-align: center; padding: 36px 0; color: #666; font-size: 13.5px; }
+      .dsh-cron-checkbox-row { display: flex; align-items: center; gap: 8px; font-size: 13px; color: #ccc; cursor: pointer; user-select: none; }
+      .dsh-cron-checkbox-row input { width: 15px; height: 15px; margin: 0; cursor: pointer; accent-color: #ededed; }
+      .dsh-cron-hint { font-size: 12px; color: #888; margin-top: 4px; }
+      .dsh-cron-status-banner { padding: 10px 14px; border-radius: 8px; font-size: 13px; margin-top: 12px; }
+      .dsh-cron-status-banner[data-type="success"] { background: rgba(16,185,129,0.15); border: 1px solid rgba(16,185,129,0.3); color: #10b981; }
+      .dsh-cron-status-banner[data-type="error"] { background: rgba(239,68,68,0.15); border: 1px solid rgba(239,68,68,0.3); color: #ef4444; }
+      .dsh-cron-status-banner[data-type="info"] { background: rgba(59,130,246,0.15); border: 1px solid rgba(59,130,246,0.3); color: #60a5fa; }
     `;
 
     function ensureStyles() {
@@ -237,6 +247,19 @@ const React = window.React || require('react');
       const [modalTab, setModalTab] = React.useState('params');
       const [taskHistory, setTaskHistory] = React.useState([]);
       const [historyLoading, setHistoryLoading] = React.useState(false);
+      const [formNotifyTelegram, setFormNotifyTelegram] = React.useState(false);
+      const [formOnlyOnFailure, setFormOnlyOnFailure] = React.useState(false);
+      const [formTimeoutSeconds, setFormTimeoutSeconds] = React.useState(1800);
+      const [formOverlapPolicy, setFormOverlapPolicy] = React.useState('skip');
+
+      // Settings modal state
+      const [settingsModalOpen, setSettingsModalOpen] = React.useState(false);
+      const [settingsBotToken, setSettingsBotToken] = React.useState('');
+      const [settingsChatId, setSettingsChatId] = React.useState('');
+      const [settingsNotifyGlobal, setSettingsNotifyGlobal] = React.useState(false);
+      const [settingsOnlyOnFailureGlobal, setSettingsOnlyOnFailureGlobal] = React.useState(false);
+      const [settingsHasDefault, setSettingsHasDefault] = React.useState(false);
+      const [testStatus, setTestStatus] = React.useState(null);
 
       // DSH dialog state
       const [dshModalOpen, setDshModalOpen] = React.useState(false);
@@ -251,6 +274,7 @@ const React = window.React || require('react');
       React.useEffect(() => {
         const onKey = (e) => {
           if (e.key !== 'Escape') return;
+          if (settingsModalOpen) { setSettingsModalOpen(false); return; }
           if (manualModalOpen) { setManualModalOpen(false); return; }
           if (dshModalOpen) { setDshModalOpen(false); return; }
           if (dropdownOpen) { setDropdownOpen(false); return; }
@@ -258,7 +282,7 @@ const React = window.React || require('react');
         };
         document.addEventListener('keydown', onKey);
         return () => document.removeEventListener('keydown', onKey);
-      }, [manualModalOpen, dshModalOpen, dropdownOpen, onClose]);
+      }, [manualModalOpen, settingsModalOpen, dshModalOpen, dropdownOpen, onClose]);
 
       const fetchTasks = async () => {
         try {
@@ -310,12 +334,78 @@ const React = window.React || require('react');
         } catch (err) {}
       };
 
+      const openSettingsModal = async () => {
+        setTestStatus(null);
+        setSettingsModalOpen(true);
+        try {
+          const res = await fetch('/dsh-cron/settings');
+          const data = await res.json();
+          if (data && data.ok && data.settings) {
+            setSettingsBotToken(data.settings.botToken || '');
+            setSettingsChatId(data.settings.chatId || '');
+            setSettingsNotifyGlobal(Boolean(data.settings.notifyTelegram));
+            setSettingsOnlyOnFailureGlobal(Boolean(data.settings.onlyOnFailure));
+            setSettingsHasDefault(Boolean(data.settings.hasDefaultCredentials));
+          }
+        } catch (e) {}
+      };
+
+      const handleSaveSettings = async (e) => {
+        e.preventDefault();
+        try {
+          const res = await fetch('/dsh-cron/settings', {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+              botToken: settingsBotToken,
+              chatId: settingsChatId,
+              notifyTelegram: settingsNotifyGlobal,
+              onlyOnFailure: settingsOnlyOnFailureGlobal
+            })
+          });
+          const data = await res.json();
+          if (data && data.ok) {
+            setSettingsModalOpen(false);
+          } else {
+            alert('Ошибка сохранения: ' + (data?.error || 'неизвестная ошибка'));
+          }
+        } catch (err) {
+          alert('Ошибка сохранения: ' + err.message);
+        }
+      };
+
+      const handleTestTelegram = async () => {
+        setTestStatus({ loading: true, message: 'Отправка тестового сообщения...' });
+        try {
+          const res = await fetch('/dsh-cron/telegram/test', {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+              botToken: settingsBotToken,
+              chatId: settingsChatId
+            })
+          });
+          const data = await res.json();
+          if (data && data.ok) {
+            setTestStatus({ loading: false, success: true, message: '✅ Тестовое сообщение успешно отправлено в Telegram!' });
+          } else {
+            setTestStatus({ loading: false, success: false, message: '❌ ' + (data?.error || 'Не удалось отправить сообщение') });
+          }
+        } catch (err) {
+          setTestStatus({ loading: false, success: false, message: '❌ ' + err.message });
+        }
+      };
+
       const openManualModal = (preset) => {
         setDropdownOpen(false);
         setFormId(null);
         setSelectedTaskMeta(null);
         setFormType('llm');
         setFormDelivery('isolated');
+        setFormNotifyTelegram(false);
+        setFormOnlyOnFailure(false);
+        setFormTimeoutSeconds(1800);
+        setFormOverlapPolicy('skip');
         if (preset) {
           setFormTitle(preset.title || '');
           setFormSchedule(preset.schedule || '');
@@ -361,6 +451,10 @@ const React = window.React || require('react');
         setFormProvider(task.provider || '');
         setFormModel(task.model || '');
         setFormDelivery(task.delivery || 'isolated');
+        setFormNotifyTelegram(Boolean(task.notifyTelegram));
+        setFormOnlyOnFailure(Boolean(task.onlyOnFailure));
+        setFormTimeoutSeconds(task.timeoutSeconds !== undefined ? task.timeoutSeconds : 1800);
+        setFormOverlapPolicy(task.overlapPolicy || 'skip');
         if (task.provider) loadModels(task.provider);
         else if (defaultModelInfo?.provider) loadModels(defaultModelInfo.provider);
         loadTaskHistory(task.id);
@@ -456,14 +550,26 @@ const React = window.React || require('react');
               React.createElement('div', { className: 'dsh-cron-title' }, 'Запланированные задачи'),
               React.createElement('div', { className: 'dsh-cron-subtitle' }, 'Попросите DSH планировать задачи, ставить напоминания или отслеживать обновления')
             ),
-            React.createElement('div', { style: { position: 'relative' } },
-              React.createElement('button', { className: 'dsh-cron-create-btn', onClick: () => setDropdownOpen(!dropdownOpen) },
-                'Создать',
-                React.createElement('span', { dangerouslySetInnerHTML: { __html: ICON_CHEVRON_DOWN } })
+            React.createElement('div', { style: { display: 'flex', alignItems: 'center', gap: '10px' } },
+              React.createElement('button', {
+                type: 'button',
+                className: 'dsh-cron-btn-secondary',
+                style: { display: 'flex', alignItems: 'center', gap: '6px', height: '36px', padding: '0 14px' },
+                title: 'Настройки Telegram и уведомлений',
+                onClick: openSettingsModal
+              },
+                React.createElement('span', { style: { display: 'flex', alignItems: 'center', color: '#60a5fa' }, dangerouslySetInnerHTML: { __html: ICON_TELEGRAM } }),
+                'Telegram & Оповещения'
               ),
-              dropdownOpen && React.createElement('div', { className: 'dsh-cron-dropdown' },
-                React.createElement('button', { className: 'dsh-cron-dropdown-item', onClick: openDshModal }, '💬 Создать с DSH'),
-                React.createElement('button', { className: 'dsh-cron-dropdown-item', onClick: () => openManualModal(null) }, '✏️ Настроить вручную')
+              React.createElement('div', { style: { position: 'relative' } },
+                React.createElement('button', { className: 'dsh-cron-create-btn', onClick: () => setDropdownOpen(!dropdownOpen) },
+                  'Создать',
+                  React.createElement('span', { dangerouslySetInnerHTML: { __html: ICON_CHEVRON_DOWN } })
+                ),
+                dropdownOpen && React.createElement('div', { className: 'dsh-cron-dropdown' },
+                  React.createElement('button', { className: 'dsh-cron-dropdown-item', onClick: openDshModal }, '💬 Создать с DSH'),
+                  React.createElement('button', { className: 'dsh-cron-dropdown-item', onClick: () => openManualModal(null) }, '✏️ Настроить вручную')
+                )
               )
             )
           ),
@@ -619,7 +725,7 @@ const React = window.React || require('react');
                       React.createElement('span', {
                         className: 'dsh-cron-history-status',
                         'data-status': run.status
-                      }, run.status === 'success' ? 'Успешно' : 'Ошибка'),
+                      }, run.status === 'success' ? 'Успешно' : run.status === 'skipped' ? 'Пропущен' : 'Ошибка'),
                       React.createElement('span', { className: 'dsh-cron-history-time' }, run.at ? new Date(run.at).toLocaleString() : '')
                     ),
                     React.createElement('span', { style: { color: '#888', fontSize: '11.5px' } }, (run.durationMs || 0) + ' ms')
@@ -673,6 +779,29 @@ const React = window.React || require('react');
                   })
                 )
               ),
+              React.createElement('div', { className: 'dsh-cron-form-row', style: { display: 'grid', gridTemplateColumns: '1fr 1fr', gap: '12px' } },
+                React.createElement('div', { className: 'dsh-cron-form-group' },
+                  React.createElement('label', null, 'Таймаут выполнения (секунды)'),
+                  React.createElement('input', {
+                    type: 'number',
+                    min: 1,
+                    value: formTimeoutSeconds,
+                    placeholder: '1800',
+                    onChange: (e) => setFormTimeoutSeconds(e.target.value)
+                  })
+                ),
+                React.createElement('div', { className: 'dsh-cron-form-group' },
+                  React.createElement('label', null, 'Политика наложения (Overlap)'),
+                  React.createElement('select', {
+                    value: formOverlapPolicy,
+                    onChange: (e) => setFormOverlapPolicy(e.target.value)
+                  },
+                    React.createElement('option', { value: 'skip' }, 'Пропустить новый запуск (skip)'),
+                    React.createElement('option', { value: 'queue' }, 'Встать в очередь (queue)'),
+                    React.createElement('option', { value: 'replace' }, 'Отменить текущий и перезапустить (replace)')
+                  )
+                )
+              ),
               formType !== 'script' && React.createElement('div', { className: 'dsh-cron-form-row', style: { display: 'grid', gridTemplateColumns: '1fr 1fr', gap: '12px' } },
                 React.createElement('div', { className: 'dsh-cron-form-group' },
                   React.createElement('label', null, 'Провайдер LLM'),
@@ -706,6 +835,36 @@ const React = window.React || require('react');
                   onChange: (e) => setFormPrompt(e.target.value)
                 })
               ),
+              React.createElement('div', {
+                style: {
+                  background: 'rgba(255,255,255,0.02)',
+                  border: '1px solid #2e2e2e',
+                  borderRadius: '8px',
+                  padding: '12px 14px',
+                  marginBottom: '16px'
+                }
+              },
+                React.createElement('div', { style: { fontWeight: 500, fontSize: '13px', color: '#eee', marginBottom: '8px', display: 'flex', alignItems: 'center', gap: '6px' } },
+                  React.createElement('span', { style: { display: 'flex', alignItems: 'center', color: '#60a5fa' }, dangerouslySetInnerHTML: { __html: ICON_TELEGRAM } }),
+                  'Уведомления в Telegram'
+                ),
+                React.createElement('label', { className: 'dsh-cron-checkbox-row', style: { marginBottom: formNotifyTelegram ? '8px' : '0' } },
+                  React.createElement('input', {
+                    type: 'checkbox',
+                    checked: formNotifyTelegram,
+                    onChange: (e) => setFormNotifyTelegram(e.target.checked)
+                  }),
+                  React.createElement('span', null, 'Отправлять отчет о выполнении в Telegram')
+                ),
+                formNotifyTelegram && React.createElement('label', { className: 'dsh-cron-checkbox-row', style: { marginLeft: '24px', marginTop: '6px' } },
+                  React.createElement('input', {
+                    type: 'checkbox',
+                    checked: formOnlyOnFailure,
+                    onChange: (e) => setFormOnlyOnFailure(e.target.checked)
+                  }),
+                  React.createElement('span', null, 'Только при ошибках (onlyOnFailure / silent mode при успехе)')
+                )
+              ),
               selectedTaskMeta && React.createElement('div', {
                 style: {
                   background: 'rgba(255,255,255,0.03)',
@@ -749,6 +908,84 @@ const React = window.React || require('react');
           )
         ),
 
+        // 1.5 Settings Modal
+        settingsModalOpen && React.createElement('div', { className: 'dsh-cron-modal-overlay', onClick: () => setSettingsModalOpen(false) },
+          React.createElement('div', { className: 'dsh-cron-modal', onClick: (e) => e.stopPropagation() },
+            React.createElement('div', { className: 'dsh-cron-modal-head', style: { display: 'flex', justifyContent: 'space-between', alignItems: 'center', marginBottom: '18px' } },
+              React.createElement('div', { className: 'dsh-cron-modal-title', style: { margin: 0, display: 'flex', alignItems: 'center', gap: '8px' } },
+                React.createElement('span', { style: { display: 'flex', alignItems: 'center', color: '#60a5fa' }, dangerouslySetInnerHTML: { __html: ICON_TELEGRAM } }),
+                'Настройки Telegram и уведомлений'
+              ),
+              React.createElement('button', {
+                type: 'button',
+                style: { background: 'none', border: 'none', color: '#888', cursor: 'pointer', fontSize: '18px' },
+                onClick: () => setSettingsModalOpen(false)
+              }, '✕')
+            ),
+            React.createElement('form', { onSubmit: handleSaveSettings },
+              React.createElement('div', { className: 'dsh-cron-form-group' },
+                React.createElement('label', null, 'Telegram Bot Token'),
+                React.createElement('input', {
+                  type: 'password',
+                  value: settingsBotToken,
+                  placeholder: settingsHasDefault ? 'Используется бот из настроек DSH (или введите свой)' : '123456789:ABCdefGhIJKlmNoPQRsTUVwxyZ',
+                  onChange: (e) => setSettingsBotToken(e.target.value)
+                }),
+                settingsHasDefault && React.createElement('div', { className: 'dsh-cron-hint' }, '✓ Обнаружен настроенный бот в профиле DSH')
+              ),
+              React.createElement('div', { className: 'dsh-cron-form-group' },
+                React.createElement('label', null, 'Telegram Chat ID'),
+                React.createElement('input', {
+                  value: settingsChatId,
+                  placeholder: 'Например: 345678901',
+                  onChange: (e) => setSettingsChatId(e.target.value)
+                })
+              ),
+              React.createElement('div', { style: { background: 'rgba(255,255,255,0.02)', border: '1px solid #2e2e2e', borderRadius: '8px', padding: '12px 14px', marginBottom: '16px' } },
+                React.createElement('label', { className: 'dsh-cron-checkbox-row', style: { marginBottom: '8px' } },
+                  React.createElement('input', {
+                    type: 'checkbox',
+                    checked: settingsNotifyGlobal,
+                    onChange: (e) => setSettingsNotifyGlobal(e.target.checked)
+                  }),
+                  React.createElement('span', null, 'Глобально отправлять отчеты всех задач в Telegram')
+                ),
+                React.createElement('label', { className: 'dsh-cron-checkbox-row' },
+                  React.createElement('input', {
+                    type: 'checkbox',
+                    checked: settingsOnlyOnFailureGlobal,
+                    onChange: (e) => setSettingsOnlyOnFailureGlobal(e.target.checked)
+                  }),
+                  React.createElement('span', null, 'Глобальный режим: Только при ошибках (silent при успехе)')
+                )
+              ),
+              React.createElement('div', { style: { display: 'flex', alignItems: 'center', justifyContent: 'space-between', marginBottom: '14px' } },
+                React.createElement('button', {
+                  type: 'button',
+                  className: 'dsh-cron-btn-secondary',
+                  style: { display: 'inline-flex', alignItems: 'center', gap: '6px' },
+                  disabled: testStatus?.loading,
+                  onClick: handleTestTelegram
+                }, testStatus?.loading ? 'Отправка...' : '🔔 Проверить отправку в Telegram')
+              ),
+              testStatus && testStatus.message && React.createElement('div', {
+                className: 'dsh-cron-status-banner',
+                'data-type': testStatus.success ? 'success' : 'error'
+              }, testStatus.message),
+              React.createElement('div', { className: 'dsh-cron-modal-foot' },
+                React.createElement('button', {
+                  type: 'button',
+                  className: 'dsh-cron-btn-secondary',
+                  onClick: () => setSettingsModalOpen(false)
+                }, 'Отмена'),
+                React.createElement('button', {
+                  type: 'submit',
+                  className: 'dsh-cron-btn-primary'
+                }, 'Сохранить настройки')
+              )
+            )
+          )
+        ),
         // 2. "Создать с DSH" modal
         dshModalOpen && React.createElement('div', { className: 'dsh-cron-modal-overlay', onClick: () => !dshLoading && setDshModalOpen(false) },
           React.createElement('div', { className: 'dsh-cron-modal', onClick: (e) => e.stopPropagation() },

package/lib/index.js

@@ -3,6 +3,7 @@ import { TaskScheduler, parseScheduleExpression } from './scheduler.js';
 import { SessionRunner } from './runner.js';
 import { getModelsHandler } from './models-handler.js';
 import { chatStartHandler } from './chat-start.js';
+import { sendTelegramMessage } from './telegram.js';
 import { defineTool } from '@deepseek-ai/dsh-tools';
 import { randomUUID } from 'node:crypto';
 
@@ -32,7 +33,7 @@ function sendJson(res, statusCode, data) {
 export function apply(ctx, config) {
   const store = new TaskStore();
   const runner = new SessionRunner(ctx);
-  const scheduler = new TaskScheduler(store, (task) => runner.execute(task));
+  const scheduler = new TaskScheduler(store, (task, opts) => runner.execute(task, opts));
 
   scheduler.start();
 
@@ -106,6 +107,10 @@ export function apply(ctx, config) {
             status: body.status || 'active',
             provider: body.provider || undefined,
             model: body.model || undefined,
+            notifyTelegram: body.notifyTelegram !== undefined ? Boolean(body.notifyTelegram) : false,
+            onlyOnFailure: body.onlyOnFailure !== undefined ? Boolean(body.onlyOnFailure) : false,
+            timeoutSeconds: body.timeoutSeconds !== undefined ? Number(body.timeoutSeconds) : 1800,
+            overlapPolicy: body.overlapPolicy || 'skip',
           });
           scheduler.scheduleTask(task);
           sendJson(res, 200, { ok: true, task });
@@ -137,6 +142,67 @@ export function apply(ctx, config) {
     }
   }), 'dsh-cron: /chat/start');
 
+  // GET & POST /dsh-cron/settings
+  ctx.effect(() => ctx.webServer.register({
+    kind: 'exact',
+    path: '/dsh-cron/settings',
+    handler: async (req, res) => {
+      try {
+        if (req.method === 'GET') {
+          sendJson(res, 200, { ok: true, settings: store.getSettings() });
+          return;
+        }
+        if (req.method === 'POST') {
+          const body = await parseJsonBody(req);
+          const updated = store.saveSettings(body);
+          sendJson(res, 200, { ok: true, settings: updated });
+          return;
+        }
+        sendJson(res, 405, { ok: false, error: 'Method not allowed' });
+      } catch (err) {
+        sendJson(res, 500, { ok: false, error: err.message });
+      }
+    }
+  }), 'dsh-cron: /settings');
+
+  // 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;
+        }
+        const body = await parseJsonBody(req);
+        const currentSettings = store.getSettings();
+        const botToken = (body.botToken || currentSettings.botToken || '').trim();
+        const chatId = (body.chatId || currentSettings.chatId || '').trim();
+
+        if (!botToken) {
+          sendJson(res, 400, { ok: false, error: 'Укажите Telegram Bot Token' });
+          return;
+        }
+        if (!chatId) {
+          sendJson(res, 400, { ok: false, error: 'Укажите Telegram Chat ID' });
+          return;
+        }
+
+        await sendTelegramMessage({
+          botToken,
+          chatId,
+          text: '⏰ *DSH Cron — Проверка связи*\nТестовое уведомление успешно доставлено! Планировщик готов к отправке отчётов.',
+          parseMode: 'Markdown'
+        });
+
+        sendJson(res, 200, { ok: true, message: 'Сообщение успешно отправлено в Telegram' });
+      } catch (err) {
+        sendJson(res, 500, { ok: false, error: err.message });
+      }
+    }
+  }), 'dsh-cron: /telegram/test');
+
   // Prefix routes for actions (/dsh-cron/action/*)
   ctx.effect(() => ctx.webServer.register({
     kind: 'prefix',
@@ -204,7 +270,11 @@ export function apply(ctx, config) {
         delivery: { type: 'string', description: 'Режим запуска: current или isolated' },
         type: { type: 'string', description: 'Тип задачи: "llm" (агент с LLM) или "script" (прямой запуск shell без LLM)' },
         provider: { type: 'string', description: 'ID провайдера LLM для выполнения задачи' },
-        model: { type: 'string', description: 'ID модели LLM для выполнения задачи' }
+        model: { type: 'string', description: 'ID модели LLM для выполнения задачи' },
+        notifyTelegram: { type: 'boolean', description: 'Отправлять отчет в Telegram' },
+        onlyOnFailure: { type: 'boolean', description: 'Отправлять в Telegram только при ошибках' },
+        timeoutSeconds: { type: 'integer', description: 'Таймаут выполнения задачи в секундах (по умолчанию 1800 = 30 мин)' },
+        overlapPolicy: { type: 'string', description: 'Политика наложения: "skip" (по умолчанию), "queue", "replace"' }
       },
       output: {
         schema: {
@@ -219,7 +289,7 @@ export function apply(ctx, config) {
           return [{ type: 'text', text: value.message }];
         }
       },
-      execute: async ({ title, schedule, prompt, delivery, provider, model, type }) => {
+      execute: async ({ title, schedule, prompt, delivery, provider, model, type, notifyTelegram, onlyOnFailure, timeoutSeconds, overlapPolicy }) => {
         try {
           const parsed = parseScheduleExpression(schedule);
           const task = store.set({
@@ -231,6 +301,10 @@ export function apply(ctx, config) {
             delivery: delivery || 'isolated',
             provider: provider || undefined,
             model: model || undefined,
+            notifyTelegram: Boolean(notifyTelegram),
+            onlyOnFailure: Boolean(onlyOnFailure),
+            timeoutSeconds: timeoutSeconds !== undefined ? Number(timeoutSeconds) : 1800,
+            overlapPolicy: overlapPolicy || 'skip',
             status: 'active'
           });
           scheduler.scheduleTask(task);
@@ -378,4 +452,4 @@ export function apply(ctx, config) {
       return;
     }
   });
-}
+}

package/lib/runner.js

@@ -6,25 +6,62 @@ export class SessionRunner {
     this.ctx = ctx;
   }
 
-    async execute(task) {
+  async execute(task, options = {}) {
+    const timeoutSeconds = Number(task.timeoutSeconds) > 0 ? Number(task.timeoutSeconds) : 1800;
+    const timeoutMs = timeoutSeconds * 1000;
+    const externalSignal = options.signal;
+
+    // Internal abort controller combining external signal + timeout
+    const controller = new AbortController();
+    let timeoutId = null;
+
+    if (externalSignal) {
+      if (externalSignal.aborted) {
+        throw new Error(externalSignal.reason?.message || 'Task aborted before execution');
+      }
+      externalSignal.addEventListener('abort', () => {
+        controller.abort(externalSignal.reason || new Error('Task aborted by overlap policy'));
+      }, { once: true });
+    }
+
+    const timeoutPromise = new Promise((_, reject) => {
+      timeoutId = setTimeout(() => {
+        const timeoutErr = new Error(`Task execution timed out after ${timeoutSeconds} seconds`);
+        controller.abort(timeoutErr);
+        reject(timeoutErr);
+      }, timeoutMs);
+    });
+
+    const executionPromise = this._run(task, controller.signal);
+
+    try {
+      return await Promise.race([executionPromise, timeoutPromise]);
+    } finally {
+      if (timeoutId) clearTimeout(timeoutId);
+    }
+  }
+
+  async _run(task, signal) {
     console.log(`[dsh-cron] executing task "${task.title}" (${task.id})`);
     
     // 1. Direct shell / script task fallback (NO-LLM)
     if (task.type === 'script' || task.mode === 'no-llm') {
       const { exec } = await import('node:child_process');
-      const { promisify } = await import('node:util');
-      const execAsync = promisify(exec);
-      try {
-        const { stdout, stderr } = await execAsync(task.prompt, {
-          timeout: 60000,
-          cwd: process.cwd()
+      return new Promise((resolve, reject) => {
+        const child = exec(task.prompt, {
+          cwd: process.cwd(),
+          signal,
+        }, (err, stdout, stderr) => {
+          if (err) {
+            if (signal && signal.aborted) {
+              return reject(signal.reason || new Error('Command aborted'));
+            }
+            return reject(err);
+          }
+          const out = (stdout || stderr || '').trim();
+          resolve(out || 'Script completed with code 0');
         });
-        const out = (stdout || stderr || '').trim();
-        return out || 'Script completed with code 0';
-      } catch (err) {
-        console.error(`[dsh-cron] script task failed:`, err.message);
-        throw err;
-      }
+      });
     }
 
     // 2. If ctx.agents is available, run through agent session (LLM)
@@ -59,6 +96,10 @@ export class SessionRunner {
           agentOptions: provider && model ? { provider, model } : undefined,
         });
 
+        if (signal && signal.aborted) {
+          throw (signal.reason || new Error('Aborted'));
+        }
+
         await handle.agent.whenIdle();
         handle.agent.followup(createUserMessage({
           content: [{ type: 'text', text: task.prompt }],
@@ -92,4 +133,4 @@ export class SessionRunner {
 
     return `[dsh-cron] Prompt triggered: "${task.prompt.slice(0, 100)}..."`;
   }
-}
+}

package/lib/scheduler.js

@@ -1,4 +1,5 @@
 import { Cron } from 'croner';
+import { shouldNotifyTask, formatTaskTelegramMessage, sendTelegramMessage } from './telegram.js';
 
 function pad(v) {
   return String(v).padStart(2, '0');
@@ -82,6 +83,7 @@ export class TaskScheduler {
     this.store = store;
     this.executeFn = executeFn;
     this.jobs = new Map();
+    this.running = new Map(); // taskId -> { controller, startedAt, queueCount }
   }
 
   start() {
@@ -100,6 +102,13 @@ export class TaskScheduler {
       } catch {}
     }
     this.jobs.clear();
+
+    for (const [, run] of this.running.entries()) {
+      try {
+        run.controller.abort(new Error('Планировщик остановлен'));
+      } catch {}
+    }
+    this.running.clear();
   }
 
   scheduleTask(task) {
@@ -131,6 +140,41 @@ export class TaskScheduler {
     const task = this.store.get(taskId);
     if (!task) return;
 
+    const overlapPolicy = task.overlapPolicy || 'skip';
+
+    // Check overlap with currently running task
+    const active = this.running.get(taskId);
+    if (active) {
+      if (overlapPolicy === 'skip') {
+        console.log(`[dsh-cron] Task "${task.title}" (${taskId}) is already running, skipping run (overlapPolicy: skip)`);
+        this.store.recordRun(taskId, {
+          at: Date.now(),
+          status: 'skipped',
+          durationMs: 0,
+          output: 'Запуск пропущен: предыдущий процесс ещё не завершился (overlapPolicy: skip)',
+          error: null,
+        });
+        return;
+      }
+      if (overlapPolicy === 'replace') {
+        console.log(`[dsh-cron] Task "${task.title}" (${taskId}) is already running, canceling current run (overlapPolicy: replace)`);
+        active.controller.abort(new Error('Прервано из-за политики overlap: replace'));
+      }
+      if (overlapPolicy === 'queue') {
+        console.log(`[dsh-cron] Task "${task.title}" (${taskId}) is already running, queueing next run (overlapPolicy: queue)`);
+        active.queueCount = (active.queueCount || 0) + 1;
+        return;
+      }
+    }
+
+    const controller = new AbortController();
+    const currentRun = {
+      controller,
+      startedAt: Date.now(),
+      queueCount: 0,
+    };
+    this.running.set(taskId, currentRun);
+
     const start = Date.now();
     let status = 'success';
     let output = '';
@@ -138,20 +182,46 @@ export class TaskScheduler {
 
     try {
       if (typeof this.executeFn === 'function') {
-        output = await this.executeFn(task);
+        output = await this.executeFn(task, { signal: controller.signal });
       }
     } catch (err) {
       status = 'error';
       error = err.message || String(err);
     } finally {
       const durationMs = Date.now() - start;
-      this.store.recordRun(taskId, {
+      const runInfo = {
         at: start,
         status,
         durationMs,
         output,
         error,
-      });
+      };
+      this.store.recordRun(taskId, runInfo);
+
+      // Clean up running map
+      const finishedRun = this.running.get(taskId);
+      if (finishedRun === currentRun) {
+        this.running.delete(taskId);
+      }
+
+      const queuedCount = finishedRun?.queueCount || 0;
+
+      // Telegram notification delivery
+      try {
+        const settings = typeof this.store.getSettings === 'function' ? this.store.getSettings() : {};
+        if (shouldNotifyTask(task, runInfo, settings)) {
+          const botToken = settings.botToken;
+          const chatId = settings.chatId;
+          if (botToken && chatId) {
+            const text = formatTaskTelegramMessage(task, runInfo);
+            sendTelegramMessage({ botToken, chatId, text }).catch((err) => {
+              console.error(`[dsh-cron] telegram delivery failed for task "${task.title}":`, err.message);
+            });
+          }
+        }
+      } catch (notifyErr) {
+        console.error('[dsh-cron] notification error:', notifyErr.message);
+      }
 
       const job = this.jobs.get(taskId);
       if (job) {
@@ -159,6 +229,12 @@ export class TaskScheduler {
         task.nextRunAt = next ? next.getTime() : null;
         this.store.set(task);
       }
+
+      if (queuedCount > 0) {
+        setImmediate(() => {
+          this.runTask(taskId);
+        });
+      }
     }
   }
 
@@ -171,6 +247,11 @@ export class TaskScheduler {
       this.jobs.get(taskId).stop();
       this.jobs.delete(taskId);
     }
+    const running = this.running.get(taskId);
+    if (running) {
+      running.controller.abort(new Error('Задача приостановлена'));
+      this.running.delete(taskId);
+    }
     this.store.set(task);
     return task;
   }
@@ -189,6 +270,11 @@ export class TaskScheduler {
       this.jobs.get(taskId).stop();
       this.jobs.delete(taskId);
     }
+    const running = this.running.get(taskId);
+    if (running) {
+      running.controller.abort(new Error('Задача удалена'));
+      this.running.delete(taskId);
+    }
     return this.store.delete(taskId);
   }
 
@@ -202,4 +288,4 @@ export class TaskScheduler {
       return null;
     }
   }
-}
+}

package/lib/store.js

@@ -1,5 +1,6 @@
 import fs from 'node:fs';
 import path from 'node:path';
+import { getDshDefaultTelegramCredentials } from './telegram.js';
 
 export function getDefaultStorePath() {
   const base = process.env.DSH_DATA_DIR || path.join(process.env.HOME || '.', '.dsh', 'data');
@@ -11,6 +12,7 @@ export class TaskStore {
     this.filePath = filePath || getDefaultStorePath();
     this.tasks = new Map();
     this.history = new Map();
+    this.settings = {};
     this.init();
   }
 
@@ -33,6 +35,9 @@ export class TaskStore {
             this.history.set(k, Array.isArray(v) ? v : []);
           }
         }
+        if (data.settings && typeof data.settings === 'object') {
+          this.settings = data.settings;
+        }
       }
     } catch (err) {
       console.error('[dsh-cron] store read error:', err.message);
@@ -50,6 +55,7 @@ export class TaskStore {
         updatedAt: new Date().toISOString(),
         tasks: Array.from(this.tasks.values()),
         history: Object.fromEntries(this.history.entries()),
+        settings: this.settings || {},
       };
       const tmp = this.filePath + '.tmp.' + Date.now();
       fs.writeFileSync(tmp, JSON.stringify(data, null, 2), 'utf-8');
@@ -59,6 +65,29 @@ export class TaskStore {
     }
   }
 
+  getSettings() {
+    const defaults = getDshDefaultTelegramCredentials();
+    return {
+      botToken: this.settings.botToken !== undefined ? this.settings.botToken : (defaults.botToken || ''),
+      chatId: this.settings.chatId !== undefined ? this.settings.chatId : (defaults.chatId || ''),
+      notifyTelegram: Boolean(this.settings.notifyTelegram),
+      onlyOnFailure: Boolean(this.settings.onlyOnFailure),
+      hasDefaultCredentials: Boolean(defaults.botToken && defaults.chatId),
+    };
+  }
+
+  saveSettings(newSettings = {}) {
+    this.settings = {
+      ...this.settings,
+      botToken: newSettings.botToken !== undefined ? String(newSettings.botToken).trim() : (this.settings.botToken || ''),
+      chatId: newSettings.chatId !== undefined ? String(newSettings.chatId).trim() : (this.settings.chatId || ''),
+      notifyTelegram: newSettings.notifyTelegram !== undefined ? Boolean(newSettings.notifyTelegram) : Boolean(this.settings.notifyTelegram),
+      onlyOnFailure: newSettings.onlyOnFailure !== undefined ? Boolean(newSettings.onlyOnFailure) : Boolean(this.settings.onlyOnFailure),
+    };
+    this.save();
+    return this.getSettings();
+  }
+
   list(filter = {}) {
     let all = Array.from(this.tasks.values());
     if (filter.status && filter.status !== 'all') {
@@ -96,6 +125,10 @@ export class TaskStore {
       delivery: task.delivery !== undefined ? task.delivery : (prev.delivery || 'isolated'),
       provider: task.provider !== undefined ? task.provider : prev.provider,
       model: task.model !== undefined ? task.model : prev.model,
+      notifyTelegram: task.notifyTelegram !== undefined ? Boolean(task.notifyTelegram) : (prev.notifyTelegram || false),
+      onlyOnFailure: task.onlyOnFailure !== undefined ? Boolean(task.onlyOnFailure) : (prev.onlyOnFailure || false),
+      timeoutSeconds: task.timeoutSeconds !== undefined ? Number(task.timeoutSeconds) : (prev.timeoutSeconds || 1800),
+      overlapPolicy: task.overlapPolicy !== undefined ? String(task.overlapPolicy) : (prev.overlapPolicy || 'skip'),
       createdAt: prev.createdAt || task.createdAt || now,
       updatedAt: now,
       lastRunAt: task.lastRunAt !== undefined ? task.lastRunAt : (prev.lastRunAt || null),
@@ -141,4 +174,4 @@ export class TaskStore {
     const runs = this.history.get(id) || [];
     return runs.slice(0, limit);
   }
-}
+}

package/lib/telegram.js

@@ -0,0 +1,147 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+
+/**
+ * Extract simple key from YAML text without external dependencies.
+ */
+export function extractSettingFromYaml(text, section, key) {
+  if (!text) return undefined;
+  const lines = text.split('\n');
+  let inside = false;
+  for (const line of lines) {
+    if (/^[^\s#]/.test(line)) inside = line.startsWith(section + ':');
+    if (!inside) continue;
+    const hit = new RegExp('^[ \t]+' + key + ':[ \t]*(.+?)[ \t]*$').exec(line);
+    if (hit) return hit[1].replace(/^['"]|['"]$/g, '').trim();
+  }
+  return undefined;
+}
+
+/**
+ * Extract first allowed chat id from YAML allowedUserIds list.
+ */
+export function extractFirstAllowedChatId(text) {
+  if (!text) return undefined;
+  const lines = text.split('\n');
+  let armed = false;
+  for (const line of lines) {
+    if (/allowedUserIds:/.test(line)) { armed = true; continue; }
+    if (!armed) continue;
+    const hit = /^\s*-\s*(\d+)\s*$/.exec(line);
+    if (hit) return hit[1];
+    if (/^\s*[a-zA-Z]/.test(line)) return undefined;
+  }
+  return undefined;
+}
+
+/**
+ * Read system DSH settings for fallback credentials.
+ */
+export function getDshDefaultTelegramCredentials() {
+  try {
+    const p = path.join(process.env.HOME || os.homedir(), '.dsh', 'settings.yaml');
+    if (fs.existsSync(p)) {
+      const raw = fs.readFileSync(p, 'utf-8');
+      const botToken = extractSettingFromYaml(raw, 'dsh-messenger-gateway', 'botToken');
+      const chatId = extractFirstAllowedChatId(raw);
+      return { botToken, chatId };
+    }
+  } catch {}
+  return { botToken: undefined, chatId: undefined };
+}
+
+/**
+ * Escape markdown special characters for Telegram legacy markdown.
+ */
+export function escapeMarkdown(str) {
+  if (!str) return '';
+  return String(str).replace(/[_*[\]()~`>#+\-=|{}.!]/g, '\\$&');
+}
+
+/**
+ * Format task execution report for Telegram.
+ */
+export function formatTaskTelegramMessage(task, runInfo) {
+  const isSuccess = runInfo.status === 'success';
+  const statusEmoji = isSuccess ? '✅' : '❌';
+  const statusText = isSuccess ? 'Успешно' : 'Ошибка';
+  const duration = runInfo.durationMs != null ? `${runInfo.durationMs} ms` : '—';
+  const title = task.title || 'Задача';
+  const schedule = task.scheduleText || task.schedule || '';
+
+  const lines = [
+    `⏰ *DSH Cron:* ${title}`,
+    `*Статус:* ${statusEmoji} ${statusText}`,
+    schedule ? `*Расписание:* ${schedule}` : null,
+    `*Длительность:* ${duration}`,
+  ].filter(Boolean);
+
+  if (runInfo.error) {
+    const errText = String(runInfo.error).slice(0, 1500);
+    lines.push('', '*Ошибка:*', '```', errText, '```');
+  } else if (runInfo.output && isSuccess) {
+    const outText = String(runInfo.output).trim().slice(0, 2000);
+    if (outText) {
+      lines.push('', '*Вывод:*', '```', outText, '```');
+    }
+  }
+
+  return lines.join('\n');
+}
+
+/**
+ * Send telegram message via Bot API.
+ */
+export async function sendTelegramMessage({ botToken, chatId, text, parseMode = 'Markdown' }) {
+  if (!botToken) throw new Error('Telegram botToken не указан');
+  if (!chatId) throw new Error('Telegram chatId не указан');
+
+  const url = `https://api.telegram.org/bot${botToken}/sendMessage`;
+  const body = {
+    chat_id: chatId,
+    text,
+    disable_notification: false,
+  };
+  if (parseMode) body.parse_mode = parseMode;
+
+  const res = await fetch(url, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify(body),
+  });
+
+  const data = await res.json().catch(() => ({}));
+  if (!res.ok || !data.ok) {
+    if (parseMode && data.description && data.description.includes("can't parse entities")) {
+      delete body.parse_mode;
+      const retryRes = await fetch(url, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify(body),
+      });
+      const retryData = await retryRes.json().catch(() => ({}));
+      if (retryRes.ok && retryData.ok) {
+        return retryData;
+      }
+    }
+    const msg = data.description || res.statusText || `HTTP ${res.status}`;
+    throw new Error(`Telegram API Error: ${msg}`);
+  }
+  return data;
+}
+
+/**
+ * Determine if a notification should be sent for a given task and run result.
+ */
+export function shouldNotifyTask(task, runInfo, globalSettings = {}) {
+  const isEnabled = task.notifyTelegram ?? globalSettings.notifyTelegram ?? false;
+  if (!isEnabled) return false;
+
+  const onlyOnFail = task.onlyOnFailure ?? globalSettings.onlyOnFailure ?? false;
+  if (onlyOnFail && runInfo.status !== 'error') {
+    return false;
+  }
+
+  return true;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@goodandready/dsh-cron",
-  "version": "0.1.14",
+  "version": "0.1.16",
   "description": "Scheduled cron tasks, background automation and agent execution for DeepSeek Harness.",
   "type": "module",
   "main": "lib/index.js",