@goodandready/dsh-cron 0.2.9 → 0.2.11

package/lib/index.js

@@ -3,7 +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 { sendTelegramMessage, createTelegramTaskKeyboard } from './telegram.js';
 import { createKanbanCard } from './integrations.js';
 import { defineTool } from '@deepseek-ai/dsh-tools';
 import { randomUUID } from 'node:crypto';
@@ -393,6 +393,24 @@ export function apply(ctx, config) {
     handler: createCronApiHandler(store, scheduler, null)
   }), 'dsh-cron: /action/:id/:action');
 
+  ctx.effect(() => ctx.webServer.register({
+    kind: 'prefix',
+    path: '/dsh-cron/telegram',
+    handler: createCronApiHandler(store, scheduler, null)
+  }), 'dsh-cron: /telegram[...]');
+
+  ctx.effect(() => ctx.webServer.register({
+    kind: 'prefix',
+    path: '/dsh-cron/heartbeat-ping',
+    handler: createCronApiHandler(store, scheduler, null)
+  }), 'dsh-cron: /heartbeat-ping[...]');
+
+  ctx.effect(() => ctx.webServer.register({
+    kind: 'prefix',
+    path: '/dsh-cron/schedule',
+    handler: createCronApiHandler(store, scheduler, null)
+  }), 'dsh-cron: /schedule[...]');
+
   // GET /dsh-cron/metrics (#53) — Prometheus text exposition
   ctx.effect(() => ctx.webServer.register({
     kind: 'exact',
@@ -527,7 +545,8 @@ export function apply(ctx, config) {
         }
 
         const text = `🔔 *dsh-cron test notification*\n\nConnection between DSH Cron and Telegram is working! Checked at: \`${new Date().toISOString()}\``;
-        await sendTelegramMessage({ botToken, chatId, text });
+        const replyMarkup = createTelegramTaskKeyboard(task, runInfo);
+        await sendTelegramMessage({ botToken, chatId, text, replyMarkup });
         sendJson(res, 200, { ok: true, message: 'Test message sent successfully' });
       } catch (err) {
         sendJson(res, 500, { ok: false, error: err.message });

package/lib/llm-actions.js

@@ -0,0 +1,141 @@
+import fs from 'node:fs';
+
+/**
+ * Extract structured action directives from LLM output text (#137).
+ * Supports JSON code fences ```json ... ``` and inline { "dsh_action": ... } blocks.
+ */
+export function parseLlmActionDirectives(text) {
+  if (!text || typeof text !== 'string') return [];
+  const directives = [];
+
+  // 1. Check for ```json ... ``` or ``` ... ``` blocks
+  const blockRegex = /```(?:json)?\s*([\s\S]*?)\s*```/gi;
+  let match;
+  while ((match = blockRegex.exec(text)) !== null) {
+    const raw = match[1].trim();
+    if ((raw.startsWith('{') && raw.endsWith('}')) || (raw.startsWith('[') && raw.endsWith(']'))) {
+      try {
+        const parsed = JSON.parse(raw);
+        collectDirectives(parsed, directives);
+      } catch {}
+    }
+  }
+
+  // 2. Check for inline JSON object with dsh_action or dsh_actions if nothing found in fences
+  if (directives.length === 0) {
+    const inlineMatch = /\{(?:[^{}]|(\{(?:[^{}]|\{[^{}]*\})*\}))*"dsh_action[s]?"(?:[^{}]|(\{(?:[^{}]|\{[^{}]*\})*\}))*\}/gi;
+    let im;
+    while ((im = inlineMatch.exec(text)) !== null) {
+      try {
+        const parsed = JSON.parse(im[0]);
+        collectDirectives(parsed, directives);
+      } catch {}
+    }
+  }
+
+  return directives;
+}
+
+function collectDirectives(obj, list) {
+  if (!obj || typeof obj !== 'object') return;
+  if (Array.isArray(obj)) {
+    for (const item of obj) collectDirectives(item, list);
+    return;
+  }
+  if (Array.isArray(obj.dsh_actions)) {
+    for (const item of obj.dsh_actions) collectDirectives(item, list);
+    return;
+  }
+  if (Array.isArray(obj.actions)) {
+    for (const item of obj.actions) collectDirectives(item, list);
+    return;
+  }
+  const type = obj.dsh_action || obj.action || obj.type;
+  if (typeof type === 'string' && type.trim()) {
+    list.push({
+      type: type.trim(),
+      payload: obj.payload || {},
+      ...obj,
+    });
+  }
+}
+
+/**
+ * Execute parsed LLM action directives if enabled in plugin settings (#137).
+ */
+export async function executeLlmActionDirectives({ directives, task, runInfo, scheduler, store, settings = {}, fetchFn = globalThis.fetch }) {
+  if (!Array.isArray(directives) || directives.length === 0) return [];
+  if (!settings.llmActionsEnabled) {
+    return [];
+  }
+
+  const results = [];
+  for (const dir of directives) {
+    const type = dir.type || dir.action;
+    try {
+      if (type === 'trigger_task' || type === 'run_task') {
+        const targetId = dir.taskId || dir.payload?.taskId;
+        if (targetId && typeof scheduler.runNow === 'function') {
+          await scheduler.runNow(targetId, {
+            prevOutput: runInfo?.output || '',
+            prevTaskId: task?.id || '',
+          });
+          results.push({ type, targetId, status: 'triggered' });
+        }
+      } else if (type === 'notify') {
+        const msg = dir.message || dir.text || dir.payload?.message;
+        const botToken = settings.botToken;
+        const chatId = settings.chatId;
+        if (msg && botToken && chatId) {
+          const url = `https://api.telegram.org/bot${botToken}/sendMessage`;
+          await fetchFn(url, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ chat_id: chatId, text: String(msg) }),
+          });
+          results.push({ type, status: 'sent' });
+        }
+      } else if (type === 'create_issue') {
+        const title = dir.title || dir.payload?.title || `Issue from task ${task?.title || 'Cron'}`;
+        const body = dir.body || dir.payload?.body || String(runInfo?.output || '');
+        const giteaRes = await tryCreateGiteaIssue({ title, body, fetchFn });
+        results.push({ type, status: giteaRes ? 'created' : 'skipped', details: giteaRes });
+      }
+    } catch (err) {
+      console.warn(`[dsh-cron] action directive ${type} execution failed:`, err.message);
+      results.push({ type, status: 'error', error: err.message });
+    }
+  }
+
+  return results;
+}
+
+/**
+ * Best-effort helper to post an issue to local Gitea if credentials are present.
+ */
+async function tryCreateGiteaIssue({ title, body, repo = 'goodandready/dsh-cron', fetchFn }) {
+  try {
+    let token = process.env.GITEA_TOKEN;
+    const credPath = '/mnt/external/Project/DEV/.gitea-agent-credentials.json';
+    if (!token && fs.existsSync(credPath)) {
+      const data = JSON.parse(fs.readFileSync(credPath, 'utf-8'));
+      token = data?.agents?.antigravity?.token || data?.token;
+    }
+    if (!token) return null;
+
+    const url = `http://127.0.0.1:3005/api/v1/repos/${repo}/issues`;
+    const res = await fetchFn(url, {
+      method: 'POST',
+      headers: {
+        'Authorization': `token ${token}`,
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify({ title, body }),
+    });
+    if (res.ok) {
+      const json = await res.json().catch(() => ({}));
+      return { number: json.number, url: json.html_url };
+    }
+  } catch {}
+  return null;
+}

package/lib/metrics.js

@@ -36,7 +36,7 @@ function sample(name, labels, value) {
  * Render the current scheduler state as Prometheus text exposition.
  * Pure function over plain data so it is testable without a store.
  */
-export function renderMetrics({ tasks = [], stats = {}, runCounters = {} } = {}) {
+export function renderMetrics({ tasks = [], stats = {}, runCounters = {}, scheduler } = {}) {
   const lines = [];
   const byStatus = {};
   for (const task of tasks) {
@@ -72,6 +72,28 @@ export function renderMetrics({ tasks = [], stats = {}, runCounters = {} } = {})
   lines.push('# TYPE dsh_cron_run_records gauge');
   lines.push('dsh_cron_run_records ' + (Number(stats.totalRuns) || 0));
 
+  if (scheduler && typeof scheduler.runningCount === 'function') {
+    lines.push('# HELP dsh_cron_concurrent_running Number of currently executing tasks.');
+    lines.push('# TYPE dsh_cron_concurrent_running gauge');
+    lines.push('dsh_cron_concurrent_running ' + (Number(scheduler.runningCount()) || 0));
+  }
+
+  lines.push('# HELP dsh_cron_task_tokens_total Cumulative tokens consumed by task.');
+  lines.push('# TYPE dsh_cron_task_tokens_total counter');
+  for (const task of tasks) {
+    if (Number(task.totalTokens) > 0) {
+      lines.push(sample('dsh_cron_task_tokens_total', { task: task.id }, task.totalTokens));
+    }
+  }
+
+  lines.push('# HELP dsh_cron_task_cost_usd_total Estimated cumulative LLM cost in USD.');
+  lines.push('# TYPE dsh_cron_task_cost_usd_total counter');
+  for (const task of tasks) {
+    if (Number(task.totalCostUsd) > 0) {
+      lines.push(sample('dsh_cron_task_cost_usd_total', { task: task.id }, task.totalCostUsd));
+    }
+  }
+
   return lines.join(NL) + NL;
 }
 
@@ -90,6 +112,7 @@ export function createMetricsHandler({ store, scheduler }) {
       tasks: store.list({ status: 'all' }),
       stats: store.getAggregatedStats(),
       runCounters: typeof scheduler.getRunCounters === 'function' ? scheduler.getRunCounters() : {},
+      scheduler,
     });
     res.writeHead(200, { 'Content-Type': METRICS_CONTENT_TYPE, 'Cache-Control': 'no-store' });
     res.end(req.method === 'HEAD' ? undefined : body);

package/lib/runner.js

@@ -54,7 +54,7 @@ export class SessionRunner {
       }, timeoutMs);
     });
 
-    const executionPromise = this._run(task, controller.signal);
+    const executionPromise = this._run(task, controller.signal, options);
 
     try {
       return await Promise.race([executionPromise, timeoutPromise]);
@@ -195,7 +195,7 @@ export class SessionRunner {
   }
 
   /** Non-LLM runtimes: shell, Node.js, Python, HTTP, SSH, Docker (#4 #5 #7 #8 #9). */
-  async _runExternal(task, runtime, signal) {
+  async _runExternal(task, runtime, signal, execOptions = {}) {
     if (runtime === 'ssh' && task.sshProfileId) {
       const viaService = await this._runViaRemoteWorkspace(task, signal);
       if (viaService) return viaService;
@@ -239,9 +239,13 @@ export class SessionRunner {
         signal.addEventListener('abort', abortHandler, { once: true });
       }
 
+      const runEnv = { ...invocation.env };
+      if (execOptions?.prevOutput !== undefined) {
+        runEnv.DSH_PREV_OUTPUT = String(execOptions.prevOutput);
+      }
       const options = {
         cwd,
-        env: invocation.env,
+        env: runEnv,
         detached: isPosix,
         stdio: ['ignore', 'pipe', 'pipe'],
       };
@@ -293,27 +297,27 @@ export class SessionRunner {
     });
   }
 
-  async _run(task, signal) {
+  async _run(task, signal, options = {}) {
     console.log(`[dsh-cron] executing task "${task.title}" (${task.id})`);
 
     // 1. Non-LLM runtimes: shell, Node.js, Python, HTTP, SSH, Docker (#4 #5 #7 #8 #9)
     const runtime = normalizeTaskType(task.type);
     if (EXTERNAL_RUNTIMES.includes(runtime) || task.mode === 'no-llm') {
-      return this._runExternal(task, runtime === 'llm' ? 'script' : runtime, signal);
+      return this._runExternal(task, runtime === 'llm' ? 'script' : runtime, signal, options);
     }
 
     // 2. Agent session, when the harness exposes one
     if (this.ctx && this.ctx.agents && typeof this.ctx.agents.create === 'function') {
-      return this._runAgentSession(task, runtime, signal);
+      return this._runAgentSession(task, runtime, signal, options);
     }
 
     // 3. Legacy session service
     if (this.ctx && this.ctx.session && typeof this.ctx.session.create === 'function') {
-      return this._runLegacySession(task);
+      return this._runLegacySession(task, options);
     }
 
     // 4. Nothing to run through: report the prompt as triggered
-    return this._runBare(task);
+    return this._runBare(task, options);
   }
 
   /** Legacy session service path; falls back to the bare report. */
@@ -336,7 +340,7 @@ export class SessionRunner {
     return this._runBare(task);
   }
 
-  _runBare(task) {
+  _runBare(task, execOptions = {}) {
     return {
       output: `[dsh-cron] Prompt triggered: "${task.prompt.slice(0, 100)}..."`,
       usage: { inputTokens: 0, outputTokens: 0, cacheReadTokens: 0 },
@@ -344,9 +348,18 @@ export class SessionRunner {
     };
   }
 
-  async _runAgentSession(task, runtime, signal) {
+  async _runAgentSession(task, runtime, signal, execOptions = {}) {
     try {
-      const prep = await this._prepareAgentRun(task, runtime, signal);
+      let effectiveTask = task;
+      if (execOptions?.prevOutput) {
+        const prev = String(execOptions.prevOutput);
+        const prompt = task.prompt || '';
+        const newPrompt = prompt.includes('{{prevOutput}}')
+          ? prompt.replaceAll('{{prevOutput}}', prev)
+          : `[Previous Output]:\n${prev}\n\n${prompt}`;
+        effectiveTask = { ...task, prompt: newPrompt };
+      }
+      const prep = await this._prepareAgentRun(effectiveTask, runtime, signal);
       return await this._executeAgentTurn(task, prep);
     } catch (err) {
       console.error(`[dsh-cron] agent execution failed:`, err.message);