skimpyclaw 0.2.0 → 0.3.0

package/dist/__tests__/cron.test.js

@@ -1,5 +1,5 @@
 import { describe, it, expect } from 'vitest';
-import { parseDualOutput } from '../cron.js';
+import { parseDualOutput, validatePrReviewOutput } from '../cron.js';
 describe('parseDualOutput', () => {
     it('returns full response as text when no delimiters present', () => {
         const response = 'Hello, this is a regular response with no delimiters.';
@@ -64,3 +64,53 @@ Voice content here
         expect(result.text).toBe(fullResponse);
     });
 });
+describe('validatePrReviewOutput', () => {
+    it('returns null for NO_CANDIDATES result', () => {
+        const output = 'No PRs found.\n[PR_REVIEW_RESULT: NO_CANDIDATES]';
+        expect(validatePrReviewOutput(output)).toBeNull();
+    });
+    it('returns null when candidates were reviewed with code_with_agent', () => {
+        const output = 'Reviewed 3 PRs.\n[PR_REVIEW_RESULT: CANDIDATES=3 CODE_AGENT_CALLS=3 BLOCKED=0]';
+        expect(validatePrReviewOutput(output)).toBeNull();
+    });
+    it('returns null when all candidates are blocked', () => {
+        const output = 'All blocked.\n[PR_REVIEW_RESULT: CANDIDATES=2 CODE_AGENT_CALLS=0 BLOCKED=2]';
+        expect(validatePrReviewOutput(output)).toBeNull();
+    });
+    it('returns alert when candidates exist but no code_with_agent calls', () => {
+        const output = 'Inline review.\n[PR_REVIEW_RESULT: CANDIDATES=3 CODE_AGENT_CALLS=0 BLOCKED=0]';
+        const result = validatePrReviewOutput(output);
+        expect(result).not.toBeNull();
+        expect(result).toContain('code_with_agent was never called');
+        expect(result).toContain('3 PR candidate');
+    });
+    it('returns alert when result line is missing entirely', () => {
+        const output = 'The agent just rambled about PRs without following the prompt.';
+        const result = validatePrReviewOutput(output);
+        expect(result).not.toBeNull();
+        expect(result).toContain('Missing [PR_REVIEW_RESULT]');
+    });
+    it('returns null when some candidates reviewed and some blocked', () => {
+        const output = '[PR_REVIEW_RESULT: CANDIDATES=4 CODE_AGENT_CALLS=2 BLOCKED=2]';
+        expect(validatePrReviewOutput(output)).toBeNull();
+    });
+    it('returns alert when partially blocked but zero calls', () => {
+        const output = '[PR_REVIEW_RESULT: CANDIDATES=3 CODE_AGENT_CALLS=0 BLOCKED=1]';
+        const result = validatePrReviewOutput(output);
+        expect(result).not.toBeNull();
+        expect(result).toContain('code_with_agent was never called');
+    });
+});
+describe('cron job tool injection', () => {
+    it('isCronJob field exists on ExecuteToolContext', () => {
+        // Verify the field is part of the type (compile-time check via assignment)
+        const ctx = {
+            isCronJob: true,
+        };
+        expect(ctx.isCronJob).toBe(true);
+    });
+    it('isCronJob defaults to undefined when not set', () => {
+        const ctx = {};
+        expect(ctx.isCronJob).toBeUndefined();
+    });
+});

package/dist/__tests__/sandbox-runtime.test.js

@@ -4,7 +4,7 @@ const { mockSpawn, mockSpawnSync } = vi.hoisted(() => ({
     mockSpawnSync: vi.fn().mockReturnValue({ status: 0, stdout: '', stderr: '' }),
 }));
 vi.mock('child_process', () => ({ spawn: mockSpawn, spawnSync: mockSpawnSync }));
-import { createContainer, execInContainer, removeContainer, isContainerRunning, cleanupOrphans, setRuntime, resetRuntime, } from '../sandbox/runtime.js';
+import { createContainer, execInContainer, removeContainer, isContainerRunning, cleanupOrphans, setRuntime, resetRuntime, probeRuntime, } from '../sandbox/runtime.js';
 function fakeChild(exitCode, stdout = '', stderr = '', opts) {
     const stdoutCallbacks = [];
     const stderrCallbacks = [];
@@ -117,6 +117,42 @@ describe('sandbox/runtime', () => {
             expect(await isContainerRunning('ctr')).toBe(false);
         });
     });
+    describe('probeRuntime', () => {
+        it('returns preferred runtime when available', () => {
+            mockSpawnSync.mockReturnValue({ status: 0 });
+            expect(probeRuntime('docker')).toBe('docker');
+            expect(mockSpawnSync).toHaveBeenCalledWith('docker', ['--version'], { stdio: 'ignore' });
+        });
+        it('falls back to auto-detect when preferred is unavailable', () => {
+            mockSpawnSync.mockImplementation((cmd) => {
+                // preferred 'docker' fails, but 'container' succeeds
+                if (cmd === 'docker')
+                    return { status: 1 };
+                if (cmd === 'container')
+                    return { status: 0 };
+                return { status: 1 };
+            });
+            expect(probeRuntime('docker')).toBe('container');
+        });
+        it('returns null when no runtime is available', () => {
+            mockSpawnSync.mockReturnValue({ status: 1 });
+            expect(probeRuntime('docker')).toBeNull();
+        });
+        it('auto-detects without preferred runtime', () => {
+            mockSpawnSync.mockImplementation((cmd) => {
+                if (cmd === 'container')
+                    return { status: 0 };
+                return { status: 1 };
+            });
+            expect(probeRuntime()).toBe('container');
+        });
+        it('prefers container over docker in auto-detect', () => {
+            mockSpawnSync.mockReturnValue({ status: 0 });
+            expect(probeRuntime()).toBe('container');
+            // First call should be to 'container'
+            expect(mockSpawnSync.mock.calls[0][0]).toBe('container');
+        });
+    });
     describe('cleanupOrphans', () => {
         it('lists containers, filters by prefix, removes matches', async () => {
             let callCount = 0;

package/dist/__tests__/setup.test.js

@@ -133,8 +133,8 @@ describe('setup config generation', () => {
             },
         });
         expect(config.cron.jobs).toHaveLength(2);
-        expect(config.cron.jobs[0].id).toBe('starter-tech-news-hn');
-        expect(config.cron.jobs[1].id).toBe('starter-weather-7am');
+        expect(config.cron.jobs[0].id).toBe('tech-digest');
+        expect(config.cron.jobs[1].id).toBe('weather');
         expect(config.cron.jobs[1].schedule.tz).toBe('America/New_York');
         expect(config.cron.jobs[1].payload.message).toContain('Austin, TX');
         expect(config.skills.enabled).toBe(true);

package/dist/agent.js

@@ -155,6 +155,7 @@ export async function runAgentTurn(agentId, userMessage, config, modelOverride,
         approverUsername: context?.metadata?.username,
         sandboxConfig: config.sandbox,
         sessionId: context?.sessionId || String(chatIdNum ?? 'default'),
+        isCronJob: context?.metadata?.isCronJob === true,
     };
     const runTurn = async () => {
         if (toolConfig?.enabled) {

package/dist/cron.d.ts

@@ -23,6 +23,12 @@ export declare function parseDualOutput(response: string): {
     voice: string | null;
     text: string;
 };
+/**
+ * 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 declare function validatePrReviewOutput(output: string): string | null;
 export declare function getCronJobs(): {
     id: string;
     name: string;

package/dist/cron.js

@@ -139,7 +139,7 @@ async function executeJobPayload(jobDef, config) {
                 channel: getActiveChannelId() || 'telegram',
                 trigger: 'cron',
                 sessionId: jobDef.id,
-                metadata: { jobName: jobDef.name },
+                metadata: { jobName: jobDef.name, isCronJob: true },
             });
             appendCronLogLine(jobDef.id, `Agent turn completed (${response.length} chars)`);
             // Parse dual output (voice + text) if delimiters present
@@ -149,6 +149,19 @@ 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);
@@ -356,6 +369,35 @@ 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', {

package/dist/providers/anthropic.js

@@ -122,7 +122,7 @@ export async function chatWithToolsAnthropic(params) {
     const modelId = stripProvider(options.model);
     const maxIterations = toolConfig.maxIterations || 20;
     // Resolve tools once at start of agent loop
-    const includeSpawn = !!(toolContext?.chatId && toolContext?.fullConfig);
+    const includeSpawn = !!(toolContext?.fullConfig && (toolContext?.chatId || toolContext?.isCronJob));
     const toolDefs = await getToolDefinitions(toolConfig, { includeSpawnSubagent: includeSpawn, projects: toolContext?.fullConfig?.projects });
     // Enable prompt caching for system + tools
     const cacheEnabled = config.models?.promptCaching !== false;

package/dist/providers/codex.js

@@ -286,7 +286,7 @@ export async function chatWithToolsCodex(params) {
     }
     // Get tool definitions
     const { getToolDefinitions } = await import('../tools.js');
-    const includeSpawn = !!(toolContext?.chatId && toolContext?.fullConfig);
+    const includeSpawn = !!(toolContext?.fullConfig && (toolContext?.chatId || toolContext?.isCronJob));
     const toolDefs = await getToolDefinitions(toolConfig, {
         includeSpawnSubagent: includeSpawn,
         includeMcp: false,

package/dist/providers/openai.js

@@ -121,7 +121,7 @@ export async function chatWithToolsOpenAI(params, provider) {
     const modelId = stripProvider(options.model, openaiClients);
     const maxIterations = toolConfig.maxIterations || 20;
     // Resolve tools once at start
-    const includeSpawn = !!(toolContext?.chatId && toolContext?.fullConfig);
+    const includeSpawn = !!(toolContext?.fullConfig && (toolContext?.chatId || toolContext?.isCronJob));
     const toolDefs = await getToolDefinitions(toolConfig, {
         includeSpawnSubagent: includeSpawn,
         includeMcp: false,

package/dist/sandbox/index.d.ts

@@ -1,4 +1,4 @@
-export { createContainer, execInContainer, removeContainer, isContainerRunning, cleanupOrphans, setRuntime, getRuntime, resetRuntime } from './runtime.js';
+export { createContainer, execInContainer, removeContainer, isContainerRunning, cleanupOrphans, setRuntime, getRuntime, resetRuntime, probeRuntime } from './runtime.js';
 export type { ContainerOpts, ExecOpts, ExecResult } from './runtime.js';
 export { ensureContainer, releaseContainer, pruneIdle, releaseAll, SANDBOX_DEFAULTS } from './manager.js';
 export { sandboxBash, sandboxReadFile, sandboxWriteFile, sandboxListDir, sandboxGlob } from './bridge.js';

package/dist/sandbox/index.js

@@ -1,4 +1,4 @@
-export { createContainer, execInContainer, removeContainer, isContainerRunning, cleanupOrphans, setRuntime, getRuntime, resetRuntime } from './runtime.js';
+export { createContainer, execInContainer, removeContainer, isContainerRunning, cleanupOrphans, setRuntime, getRuntime, resetRuntime, probeRuntime } from './runtime.js';
 export { ensureContainer, releaseContainer, pruneIdle, releaseAll, SANDBOX_DEFAULTS } from './manager.js';
 export { sandboxBash, sandboxReadFile, sandboxWriteFile, sandboxListDir, sandboxGlob } from './bridge.js';
 export { validateMountPaths, isBlockedPath, translatePath } from './mount-security.js';

package/dist/sandbox/runtime.d.ts

@@ -24,6 +24,11 @@ export interface ExecResult {
 export declare function setRuntime(runtime: 'container' | 'docker'): void;
 /** Get the container runtime binary, auto-detecting if not explicitly set. */
 export declare function getRuntime(): string;
+/**
+ * Check if a usable container runtime is available.
+ * Returns the runtime name if found, null otherwise. Never throws.
+ */
+export declare function probeRuntime(preferred?: string): string | null;
 /** Reset runtime detection (for testing). */
 export declare function resetRuntime(): void;
 export declare function createContainer(name: string, opts: ContainerOpts): Promise<void>;

package/dist/sandbox/runtime.js

@@ -23,6 +23,26 @@ export function getRuntime() {
     }
     return runtimeBinary;
 }
+/**
+ * Check if a usable container runtime is available.
+ * Returns the runtime name if found, null otherwise. Never throws.
+ */
+export function probeRuntime(preferred) {
+    // If a preferred runtime is specified, check that one first
+    if (preferred) {
+        const result = spawnSync(preferred, ['--version'], { stdio: 'ignore' });
+        if (result.status === 0)
+            return preferred;
+    }
+    // Auto-detect: prefer Apple Containers, fall back to Docker
+    if (spawnSync('container', ['--version'], { stdio: 'ignore' }).status === 0) {
+        return 'container';
+    }
+    if (spawnSync('docker', ['--version'], { stdio: 'ignore' }).status === 0) {
+        return 'docker';
+    }
+    return null;
+}
 /** Reset runtime detection (for testing). */
 export function resetRuntime() {
     runtimeBinary = null;

package/dist/service.js

@@ -5,26 +5,34 @@ import { initActiveChannel, startActiveChannel, stopActiveChannel } from './chan
 import { initProviders } from './agent.js';
 import { initLangfuse, shutdownLangfuse } from './langfuse.js';
 import { restoreCodeAgentTasks, setCodeAgentConfig } from './tools.js';
-import { releaseAll, cleanupOrphans, setRuntime } from './sandbox/index.js';
+import { releaseAll, cleanupOrphans, setRuntime, probeRuntime } from './sandbox/index.js';
 export async function startRuntime(config) {
     const smokeTest = process.env.SKIMPYCLAW_SMOKE_TEST === '1';
     initLangfuse(config);
     initProviders(config);
     restoreCodeAgentTasks();
     setCodeAgentConfig(config);
-    // Initialize sandbox runtime if configured
-    if (config.sandbox?.runtime) {
-        setRuntime(config.sandbox.runtime);
-    }
-    // Clean up orphaned sandbox containers from previous runs
+    // Initialize sandbox runtime if configured — auto-disable if no runtime available
     if (config.sandbox?.enabled) {
-        try {
-            const count = await cleanupOrphans();
-            if (count > 0)
-                console.log(`[sandbox] Cleaned up ${count} orphaned container(s)`);
+        const detected = probeRuntime(config.sandbox.runtime);
+        if (detected) {
+            setRuntime(detected);
+            if (detected !== config.sandbox.runtime) {
+                console.log(`[sandbox] Configured runtime "${config.sandbox.runtime}" not found, using "${detected}" instead`);
+            }
+            // Clean up orphaned sandbox containers from previous runs
+            try {
+                const count = await cleanupOrphans();
+                if (count > 0)
+                    console.log(`[sandbox] Cleaned up ${count} orphaned container(s)`);
+            }
+            catch (err) {
+                console.warn('[sandbox] Failed to clean up orphaned containers:', err instanceof Error ? err.message : err);
+            }
         }
-        catch (err) {
-            console.warn('[sandbox] Failed to clean up orphaned containers:', err instanceof Error ? err.message : err);
+        else {
+            console.warn('[sandbox] No container runtime found (docker/container not installed). Sandbox disabled.');
+            config.sandbox.enabled = false;
         }
     }
     const port = smokeTest ? (parseInt(process.env.SKIMPYCLAW_SMOKE_PORT || '19999', 10)) : config.gateway.port;

package/dist/setup.js

@@ -226,8 +226,8 @@ function buildStarterCronJobs(starters) {
     const jobs = [];
     if (starters.cronTechNews) {
         jobs.push({
-            id: 'starter-tech-news-hn',
-            name: 'Tech News — Top 10 HN',
+            id: 'tech-digest',
+            name: 'Tech News',
             schedule: {
                 kind: 'cron',
                 expr: '0 8 * * *',
@@ -241,8 +241,8 @@ function buildStarterCronJobs(starters) {
     }
     if (starters.cronWeather) {
         jobs.push({
-            id: 'starter-weather-7am',
-            name: 'Weather Check — 7:00 AM',
+            id: 'weather',
+            name: 'Weather',
             schedule: {
                 kind: 'cron',
                 expr: '0 7 * * *',

package/dist/tools/execute-context.d.ts

@@ -23,6 +23,8 @@ export interface ExecuteToolContext {
     trigger?: string;
     /** Agent ID for usage tracking */
     agentId?: string;
+    /** True when this context is from a cron job — enables spawn tools even without a chatId */
+    isCronJob?: boolean;
     /** Sandbox configuration for containerized tool execution */
     sandboxConfig?: import('../types.js').SandboxConfig;
     /** Session ID for sandbox container mapping */

package/dist/voice.js

@@ -190,11 +190,18 @@ function getSTTProvider(config) {
     const isApiBackedSttProvider = (name, provider) => {
         if (!provider)
             return false;
-        // macOS voice provider is TTS-only and must never be used for transcription.
         const normalizedName = name.trim().toLowerCase();
+        // macOS is TTS-only
         if (normalizedName === 'macos')
             return false;
-        return Boolean(provider.stt || provider.apiKey);
+        // Explicit stt config — always good
+        if (provider.stt)
+            return true;
+        // Only OpenAI has a Whisper-compatible transcription endpoint by default.
+        // Other providers (elevenlabs, etc.) need explicit stt config to be used for STT.
+        if (normalizedName === 'openai' && provider.apiKey)
+            return true;
+        return false;
     };
     if (config.defaultProvider) {
         const preferredName = config.defaultProvider;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "skimpyclaw",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "Lightweight personal AI assistant with Telegram and Discord integration",
   "type": "module",
   "main": "dist/index.js",