skimpyclaw 0.3.14 → 0.4.0

package/dist/cron.js

@@ -2,15 +2,17 @@
 import { Cron } from 'croner';
 import { exec } from 'child_process';
 import { existsSync, mkdirSync, appendFileSync, readFileSync, watch } from 'fs';
-import { join } from 'path';
+import { join, resolve } from 'path';
 import { getLogsDir, getConfigPath, loadConfig, resolveAllowedPaths } from './config.js';
 import { homedir } from 'node:os';
 import { runAgentTurn } from './agent.js';
 import { startTrace, addEvent, endTrace } from './audit.js';
 import { sendActiveChannelProactiveMessage, sendActiveChannelProactiveVoice, getActiveChannelId } from './channels.js';
+import { sendToDiscordThread, sendToDiscordThreadWithVoice } from './channels/discord/index.js';
 import { parseAndSaveDigest } from './digests.js';
 import { synthesizeSpeech } from './voice.js';
 import { toErrorMessage } from './utils.js';
+import { sanitizeCronEnv } from './env-sanitizer.js';
 function safeTimezone(tz) {
     const fallback = Intl.DateTimeFormat().resolvedOptions().timeZone || 'UTC';
     if (!tz)
@@ -24,7 +26,6 @@ function safeTimezone(tz) {
         return fallback;
     }
 }
-import { ensureContainer, SANDBOX_DEFAULTS, sandboxBash } from './sandbox/index.js';
 const scheduledJobs = new Map();
 let configWatcher = null;
 function getCronLogDir() {
@@ -58,12 +59,97 @@ function appendCronLogLine(jobId, line) {
 }
 // Track currently running jobs for status queries
 const runningJobs = new Map();
+const activeExecutions = new Set();
 export function getCronRunStatus() {
     return {
         running: Array.from(runningJobs.keys()),
         recent: Array.from(runningJobs.values()),
     };
 }
+/**
+ * Send a cron notification to the configured target.
+ * If discordThreadId is set, only routes to that thread.
+ * Active-channel fallback only applies when no discordThreadId is configured.
+ * Optionally includes voice attachment if voiceBuffer and voiceFormat are provided.
+ * Returns true if sent successfully.
+ */
+async function sendCronNotification(config, message, discordThreadId, voiceBuffer, voiceFormat) {
+    if (discordThreadId) {
+        try {
+            // Use voice-enabled sender for Discord threads if voice is provided
+            if (voiceBuffer && voiceFormat) {
+                const sent = await sendToDiscordThreadWithVoice(discordThreadId, message, voiceBuffer, voiceFormat);
+                if (sent)
+                    return true;
+                console.error(`[cron] Failed to send to Discord thread ${discordThreadId} with voice; active-channel fallback disabled for thread-targeted jobs`);
+                return false;
+            }
+            const sent = await sendToDiscordThread(discordThreadId, message);
+            if (sent)
+                return true;
+            console.error(`[cron] Failed to send to Discord thread ${discordThreadId}; active-channel fallback disabled for thread-targeted jobs`);
+            return false;
+        }
+        catch (err) {
+            const errorText = err instanceof Error ? err.message : String(err);
+            console.error(`[cron] Discord thread delivery failed for ${discordThreadId}; active-channel fallback disabled: ${errorText}`);
+            return false;
+        }
+    }
+    // Fallback to active channel for non-thread-targeted jobs
+    if (voiceBuffer && voiceFormat) {
+        // Send voice to active channel if provided
+        await sendActiveChannelProactiveVoice(config, voiceBuffer, voiceFormat);
+    }
+    return sendActiveChannelProactiveMessage(config, message);
+}
+function resolveDiscordThreadTarget(jobDef) {
+    const threadId = jobDef.payload.discordThreadId?.trim();
+    if (!threadId)
+        return undefined;
+    // Discord snowflakes are numeric IDs. Validate eagerly so invalid config falls back cleanly.
+    if (!/^\d{17,20}$/.test(threadId)) {
+        console.warn(`[cron] Invalid discordThreadId for job "${jobDef.id}": ${JSON.stringify(jobDef.payload.discordThreadId)}`);
+        return undefined;
+    }
+    return threadId;
+}
+const CRON_AGENT_RETRY_DELAYS_MS = [5000, 15000];
+export function isRetryableCronAgentError(err) {
+    const message = toErrorMessage(err).toLowerCase();
+    return [
+        'codex api 503',
+        'upstream connect error',
+        'connection refused',
+        'connection reset',
+        'remote connection failure',
+        'fetch failed',
+        'econnreset',
+        'econnrefused',
+        'etimedout',
+        'overloaded_error',
+        'temporarily unavailable',
+    ].some(pattern => message.includes(pattern));
+}
+async function sleep(ms) {
+    await new Promise(resolve => setTimeout(resolve, ms));
+}
+async function runCronAgentTurnWithRetry(jobId, run) {
+    for (let attempt = 0; attempt <= CRON_AGENT_RETRY_DELAYS_MS.length; attempt++) {
+        try {
+            return await run();
+        }
+        catch (err) {
+            if (attempt >= CRON_AGENT_RETRY_DELAYS_MS.length || !isRetryableCronAgentError(err)) {
+                throw err;
+            }
+            const delayMs = CRON_AGENT_RETRY_DELAYS_MS[attempt];
+            appendCronLogLine(jobId, `Agent turn transient failure; retrying in ${(delayMs / 1000).toFixed(0)}s (${attempt + 1}/${CRON_AGENT_RETRY_DELAYS_MS.length}): ${toErrorMessage(err).slice(0, 180)}`);
+            await sleep(delayMs);
+        }
+    }
+    throw new Error('Unreachable cron retry state');
+}
 export function initCron(config) {
     // Clear existing jobs
     for (const job of scheduledJobs.values()) {
@@ -109,6 +195,10 @@ export function initCron(config) {
     }
 }
 function scheduleJob(jobDef, config) {
+    if (jobDef.enabled === false) {
+        console.log(`[cron] Skipping disabled job: ${jobDef.id}`);
+        return;
+    }
     if (jobDef.schedule.kind !== 'cron') {
         console.warn(`[cron] Unsupported schedule kind: ${jobDef.schedule.kind}`);
         return;
@@ -128,6 +218,13 @@ function scheduleJob(jobDef, config) {
     console.log(`[cron] Scheduled: ${jobDef.name} (${jobDef.schedule.expr})`);
 }
 async function executeJobPayload(jobDef, config) {
+    if (activeExecutions.has(jobDef.id)) {
+        const message = `Skipping overlapping run for job "${jobDef.id}" (previous run still active)`;
+        console.warn(`[cron] ${message}`);
+        appendCronLogLine(jobDef.id, `=== SKIPPED: overlap guard (${jobDef.id}) ===`);
+        return;
+    }
+    activeExecutions.add(jobDef.id);
     const logEntry = {
         jobId: jobDef.id,
         jobName: jobDef.name,
@@ -135,13 +232,16 @@ async function executeJobPayload(jobDef, config) {
         status: 'running',
     };
     runningJobs.set(jobDef.id, logEntry);
+    const discordThreadId = resolveDiscordThreadTarget(jobDef);
+    // Track synthesized voice for final notification
+    let synthesizedVoice = null;
     // Log start immediately
     appendCronLogLine(jobDef.id, `=== STARTED: ${jobDef.name} (${jobDef.id}) ===`);
     appendCronLogLine(jobDef.id, `Model: ${jobDef.model || 'default'}`);
     appendCronLogLine(jobDef.id, `Payload: ${jobDef.payload.kind}`);
     // Notify channel at start
     try {
-        await sendActiveChannelProactiveMessage(config, `🔄 Cron starting: ${jobDef.name}`);
+        await sendCronNotification(config, `🔄 Cron starting: ${jobDef.name}`, discordThreadId);
     }
     catch {
         // Non-critical
@@ -157,14 +257,14 @@ async function executeJobPayload(jobDef, config) {
                 bashTimeout: 15000,
             };
             const tools = jobDef.payload.tools
-                ? { ...jobDef.payload.tools, allowedPaths: jobDef.payload.tools.allowedPaths?.length ? jobDef.payload.tools.allowedPaths : resolveAllowedPaths(config) }
+                ? { ...jobDef.payload.tools, allowedPaths: resolveAllowedPaths(config, jobDef.payload.tools.allowedPaths) }
                 : defaultTools;
-            const response = await runAgentTurn(config.agents.default, message, config, jobDef.model, tools, undefined, {
+            const response = await runCronAgentTurnWithRetry(jobDef.id, () => runAgentTurn(config.agents.default, message, config, jobDef.model, tools, undefined, {
                 channel: getActiveChannelId() || 'telegram',
                 trigger: 'cron',
                 sessionId: jobDef.id,
                 metadata: { jobName: jobDef.name, isCronJob: true },
-            });
+            }));
             appendCronLogLine(jobDef.id, `Agent turn completed (${response.length} chars)`);
             // Parse dual output (voice + text) if delimiters present
             const { voice: voicePortion, text: textPortion } = parseDualOutput(response);
@@ -173,29 +273,39 @@ async function executeJobPayload(jobDef, config) {
             }
             // Use text portion for log output and notifications
             logEntry.output = textPortion.slice(0, 5000);
-            // Post-run guard for pr-review job
-            if (jobDef.id === 'pr-review') {
-                const guardAlert = validatePrReviewOutput(textPortion);
-                if (guardAlert) {
-                    appendCronLogLine(jobDef.id, guardAlert);
-                    try {
-                        await sendActiveChannelProactiveMessage(config, guardAlert);
-                    }
-                    catch {
-                        // Non-critical
-                    }
-                }
-            }
             // Parse and save digest from the text portion
             try {
-                parseAndSaveDigest(jobDef.id, jobDef.name, textPortion);
+                const digest = parseAndSaveDigest(jobDef.id, jobDef.name, textPortion);
                 appendCronLogLine(jobDef.id, 'Digest saved');
+                if (digest.articles.length > 0) {
+                    const digestMessage = digest.summary ?? textPortion;
+                    if (!digestMessage || !digestMessage.trim()) {
+                        appendCronLogLine(jobDef.id, 'Digest message is empty, skipping send');
+                    }
+                    else {
+                        try {
+                            const sent = await sendCronNotification(config, digestMessage, discordThreadId);
+                            if (sent) {
+                                appendCronLogLine(jobDef.id, `Digest sent to chat (${digestMessage.length} chars)`);
+                            }
+                            else if (discordThreadId) {
+                                appendCronLogLine(jobDef.id, `Digest thread delivery failed (threadId=${discordThreadId}); no active-channel fallback`);
+                            }
+                            else {
+                                appendCronLogLine(jobDef.id, 'Failed to send digest to chat');
+                            }
+                        }
+                        catch {
+                            appendCronLogLine(jobDef.id, 'Failed to send digest to chat');
+                        }
+                    }
+                }
             }
             catch (digestErr) {
                 const errMsg = digestErr instanceof Error ? digestErr.message : String(digestErr);
                 appendCronLogLine(jobDef.id, `Failed to save digest: ${errMsg}`);
             }
-            // Synthesize and send voice if configured
+            // Synthesize voice if configured (stored for final notification)
             if (jobDef.payload.sendAsVoice && config.voice) {
                 try {
                     // Use voice portion if available, fall back to text
@@ -203,13 +313,9 @@ async function executeJobPayload(jobDef, config) {
                     appendCronLogLine(jobDef.id, `Synthesizing voice (${voicePortion ? 'voice portion' : 'full text fallback'})...`);
                     const speech = await synthesizeSpeech(voiceContent, config.voice);
                     appendCronLogLine(jobDef.id, `Voice synthesized (${speech.format}, ${speech.provider}, ${speech.buffer.length} bytes)`);
-                    const sent = await sendActiveChannelProactiveVoice(config, speech.buffer, speech.format);
-                    if (sent) {
-                        appendCronLogLine(jobDef.id, 'Voice message sent to active channel');
-                    }
-                    else {
-                        appendCronLogLine(jobDef.id, 'No active channel for voice message');
-                    }
+                    // Store for final notification instead of sending immediately
+                    synthesizedVoice = { buffer: speech.buffer, format: speech.format };
+                    appendCronLogLine(jobDef.id, 'Voice stored for final notification');
                 }
                 catch (voiceErr) {
                     const errMsg = voiceErr instanceof Error ? voiceErr.message : String(voiceErr);
@@ -236,6 +342,15 @@ async function executeJobPayload(jobDef, config) {
                     durationMs: 0,
                 });
                 await endTrace(scriptTraceId, 'ok');
+                // Parse and save digest from script output (same as agentTurn path)
+                try {
+                    const digest = parseAndSaveDigest(jobDef.id, jobDef.name, output);
+                    appendCronLogLine(jobDef.id, `Digest saved: ${digest.articles.length} articles`);
+                }
+                catch (digestErr) {
+                    const errMsg = digestErr instanceof Error ? digestErr.message : String(digestErr);
+                    appendCronLogLine(jobDef.id, `Failed to save digest: ${errMsg}`);
+                }
             }
             catch (scriptErr) {
                 const scriptErrMsg = scriptErr instanceof Error ? scriptErr.message : String(scriptErr);
@@ -263,9 +378,10 @@ async function executeJobPayload(jobDef, config) {
         logEntry.durationMs = new Date(logEntry.finishedAt).getTime() - new Date(logEntry.startedAt).getTime();
         writeCronLog(logEntry);
         runningJobs.delete(jobDef.id);
+        activeExecutions.delete(jobDef.id);
         const elapsed = (logEntry.durationMs / 1000).toFixed(1);
         console.log(`[cron] Job ${jobDef.id} finished: ${logEntry.status} (${elapsed}s)`);
-        // Notify active channel
+        // Notify active channel with optional voice attachment
         try {
             const icon = logEntry.status === 'success' ? '✅' : logEntry.status === 'timeout' ? '⏰' : '❌';
             let notification = `${icon} Cron: ${jobDef.name} — ${logEntry.status} (${elapsed}s)`;
@@ -279,7 +395,20 @@ async function executeJobPayload(jobDef, config) {
                     : logEntry.output;
                 notification += `\n\n${output}`;
             }
-            await sendActiveChannelProactiveMessage(config, notification);
+            // Include synthesized voice if available
+            if (synthesizedVoice) {
+                appendCronLogLine(jobDef.id, `Sending notification with voice (${synthesizedVoice.format})`);
+                const sent = await sendCronNotification(config, notification, discordThreadId, synthesizedVoice.buffer, synthesizedVoice.format);
+                if (!sent && discordThreadId) {
+                    appendCronLogLine(jobDef.id, `Final thread notification delivery failed (threadId=${discordThreadId}); no active-channel fallback`);
+                }
+            }
+            else {
+                const sent = await sendCronNotification(config, notification, discordThreadId);
+                if (!sent && discordThreadId) {
+                    appendCronLogLine(jobDef.id, `Final thread notification delivery failed (threadId=${discordThreadId}); no active-channel fallback`);
+                }
+            }
         }
         catch (notifyErr) {
             console.error(`[cron] Failed to send notification: ${notifyErr}`);
@@ -296,19 +425,6 @@ async function executeScript(jobDef, config) {
         throw new Error(`Working directory does not exist: ${cwd}`);
     }
     const timeoutMs = jobDef.payload.timeoutMs || 600000; // 10 min default
-    // Sandbox routing for script payloads
-    const sandboxCfg = config.sandbox;
-    if (sandboxCfg?.enabled) {
-        const merged = { ...SANDBOX_DEFAULTS, ...sandboxCfg };
-        const containerName = await ensureContainer(`cron-${jobDef.id}`, merged, jobDef.payload.tools?.allowedPaths || []);
-        console.log(`[cron:script] Running in sandbox container: ${containerName}`);
-        console.log(`[cron:script] Running: ${script.slice(0, 100)}${script.length > 100 ? '...' : ''}`);
-        if (cwd)
-            console.log(`[cron:script] cwd: ${cwd}`);
-        const output = await sandboxBash(containerName, script, cwd, timeoutMs);
-        console.log(`[cron:script] Sandbox completed (${output.length} chars)`);
-        return output;
-    }
     return new Promise((resolve, reject) => {
         const startTime = Date.now();
         console.log(`[cron:script] Running: ${script.slice(0, 100)}${script.length > 100 ? '...' : ''}`);
@@ -317,7 +433,7 @@ async function executeScript(jobDef, config) {
         const child = exec(script, {
             cwd: cwd || undefined,
             timeout: timeoutMs,
-            env: { ...process.env },
+            env: sanitizeCronEnv(),
             maxBuffer: 10 * 1024 * 1024, // 10MB output buffer
         }, (error, stdout, stderr) => {
             const elapsed = ((Date.now() - startTime) / 1000).toFixed(1);
@@ -352,20 +468,21 @@ function resolveMessageSource(message) {
     const trimmed = message.trim();
     if (!trimmed.endsWith('.md'))
         return message;
-    // Expand ~ to home directory
+    const promptsRoot = resolve(homedir(), '.skimpyclaw', 'prompts');
     const resolved = trimmed.startsWith('~/')
-        ? join(homedir(), trimmed.slice(2))
-        : trimmed;
+        ? resolve(homedir(), trimmed.slice(2))
+        : trimmed.startsWith('/')
+            ? resolve(trimmed)
+            : resolve(promptsRoot, trimmed);
+    const insidePromptsRoot = resolved === promptsRoot || resolved.startsWith(`${promptsRoot}/`);
+    if (!insidePromptsRoot) {
+        console.warn(`[cron] Rejected prompt path outside ~/.skimpyclaw/prompts: ${trimmed}`);
+        return message;
+    }
     if (existsSync(resolved)) {
         console.log(`[cron] Loading prompt from file: ${resolved}`);
         return readFileSync(resolved, 'utf-8');
     }
-    // Fallback: check ~/.skimpyclaw/prompts/ directory
-    const promptsDir = join(homedir(), '.skimpyclaw', 'prompts', trimmed);
-    if (existsSync(promptsDir)) {
-        console.log(`[cron] Loading prompt from prompts dir: ${promptsDir}`);
-        return readFileSync(promptsDir, 'utf-8');
-    }
     console.warn(`[cron] Could not resolve prompt file: ${trimmed}`);
     // Not a valid file path — treat as regular message text
     return message;
@@ -393,35 +510,6 @@ export function parseDualOutput(response) {
         text: text || response,
     };
 }
-/**
- * Post-run guard for the pr-review cron job.
- * Validates that the agent actually used code_with_agent when PRs were found.
- * Non-throwing — logs a warning and returns an alert message (or null if OK).
- */
-export function validatePrReviewOutput(output) {
-    // Check for the machine-readable result line
-    const resultMatch = output.match(/\[PR_REVIEW_RESULT:\s*(.+?)\]/);
-    if (!resultMatch) {
-        return '⚠️ PR Pre-Review: Missing [PR_REVIEW_RESULT] line in output. The agent may not have followed the prompt correctly.';
-    }
-    const resultLine = resultMatch[1].trim();
-    // NO_CANDIDATES is fine — nothing to review
-    if (resultLine === 'NO_CANDIDATES') {
-        return null;
-    }
-    // Parse CANDIDATES=N CODE_AGENT_CALLS=M BLOCKED=B
-    const candidatesMatch = resultLine.match(/CANDIDATES=(\d+)/);
-    const callsMatch = resultLine.match(/CODE_AGENT_CALLS=(\d+)/);
-    const blockedMatch = resultLine.match(/BLOCKED=(\d+)/);
-    const candidates = candidatesMatch ? parseInt(candidatesMatch[1], 10) : 0;
-    const calls = callsMatch ? parseInt(callsMatch[1], 10) : 0;
-    const blocked = blockedMatch ? parseInt(blockedMatch[1], 10) : 0;
-    // If there were candidates but zero code_with_agent calls (and not all blocked), alert
-    if (candidates > 0 && calls === 0 && blocked < candidates) {
-        return `⚠️ PR Pre-Review: Found ${candidates} PR candidate(s) but code_with_agent was never called (blocked: ${blocked}). The agent likely wrote inline commentary instead of delegating.`;
-    }
-    return null;
-}
 function expandVariables(message) {
     const now = new Date();
     const date = now.toLocaleDateString('en-US', {
@@ -429,8 +517,13 @@ function expandVariables(message) {
         day: 'numeric',
         year: 'numeric',
     });
+    const mm = String(now.getMonth() + 1).padStart(2, '0');
+    const dd = String(now.getDate()).padStart(2, '0');
+    const yyyy = now.getFullYear();
+    const dateMmDdYyyy = `${mm}-${dd}-${yyyy}`;
     return message
         .replace(/\{\{date\}\}/g, date)
+        .replace(/\{\{date_mm-dd-yyyy\}\}/g, dateMmDdYyyy)
         .replace(/\{\{time\}\}/g, now.toLocaleTimeString())
         .replace(/\{\{iso\}\}/g, now.toISOString());
 }