profclaw 0.0.1-beta.1

package/dist/cron/index.js

@@ -0,0 +1,37 @@
+/**
+ * Cron Jobs Index
+ *
+ * Starts and stops all background cron jobs.
+ *
+ * Configurable intervals via environment variables:
+ * - POLL_INTERVAL_HEARTBEAT: Agent health check (default: 30s)
+ * - POLL_INTERVAL_ISSUES: GitHub issue polling (default: 2m)
+ * - POLL_INTERVAL_STALE: Stale task check (default: 1m)
+ */
+import { startIssuePoller, stopIssuePoller } from './issue-poller.js';
+import { startHeartbeat, stopHeartbeat } from './heartbeat.js';
+import { startStaleChecker, stopStaleChecker } from './stale-checker.js';
+import { createContextualLogger } from '../utils/logger.js';
+const log = createContextualLogger('Cron');
+/**
+ * Start all cron jobs
+ */
+export function startAllCronJobs() {
+    log.info('Starting background jobs');
+    startHeartbeat();
+    startIssuePoller();
+    startStaleChecker();
+}
+/**
+ * Stop all cron jobs
+ */
+export function stopAllCronJobs() {
+    log.info('Stopping background jobs');
+    stopHeartbeat();
+    stopIssuePoller();
+    stopStaleChecker();
+}
+export { startIssuePoller, stopIssuePoller } from './issue-poller.js';
+export { startHeartbeat, stopHeartbeat, getHealthStatus } from './heartbeat.js';
+export { startStaleChecker, stopStaleChecker } from './stale-checker.js';
+//# sourceMappingURL=index.js.map

package/dist/cron/issue-poller.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Issue Poller
+ *
+ * Polls GitHub for new issues labeled with ai-task that aren't in the queue yet.
+ * Configurable via POLL_INTERVAL_ISSUES env var (default: 2 minutes).
+ */
+/**
+ * Start the issue poller
+ */
+export declare function startIssuePoller(): void;
+/**
+ * Stop the issue poller
+ */
+export declare function stopIssuePoller(): void;
+//# sourceMappingURL=issue-poller.d.ts.map

package/dist/cron/issue-poller.js

@@ -0,0 +1,174 @@
+/**
+ * Issue Poller
+ *
+ * Polls GitHub for new issues labeled with ai-task that aren't in the queue yet.
+ * Configurable via POLL_INTERVAL_ISSUES env var (default: 2 minutes).
+ */
+import { addTask, getTask } from '../queue/index.js';
+import { createContextualLogger } from '../utils/logger.js';
+const log = createContextualLogger('IssuePoller');
+// Configurable interval (default: 2 minutes, env var in ms)
+const POLL_INTERVAL = parseInt(process.env.POLL_INTERVAL_ISSUES || '120000', 10);
+const AI_TASK_LABEL = process.env.GITHUB_AI_TASK_LABEL || 'ai-task';
+const GITHUB_TOKEN = process.env.GITHUB_TOKEN || '';
+const REPOS_TO_POLL = (process.env.GITHUB_REPOS_TO_POLL || '').split(',').filter(Boolean);
+let pollerInterval = null;
+/**
+ * Fetch open issues with ai-task label from a repo
+ */
+async function fetchOpenIssues(owner, repo) {
+    try {
+        const response = await fetch(`https://api.github.com/repos/${owner}/${repo}/issues?state=open&labels=${AI_TASK_LABEL}&per_page=20`, {
+            headers: {
+                Authorization: `Bearer ${GITHUB_TOKEN}`,
+                Accept: 'application/vnd.github+json',
+                'User-Agent': 'profclaw',
+            },
+        });
+        if (!response.ok) {
+            log.warn(`Failed to fetch issues from ${owner}/${repo}`, { status: response.status });
+            return [];
+        }
+        const issues = await response.json();
+        // Filter out pull requests (GitHub API returns PRs in issues endpoint)
+        return issues.filter(issue => !issue.pull_request);
+    }
+    catch (error) {
+        log.error(`Error fetching issues from ${owner}/${repo}`, error instanceof Error ? error : undefined);
+        return [];
+    }
+}
+/**
+ * Build task input from GitHub issue
+ */
+function issueToTask(issue, repo) {
+    return {
+        title: issue.title,
+        description: issue.body || undefined,
+        prompt: buildPromptFromIssue(issue, repo),
+        priority: getPriorityFromLabels(issue.labels),
+        source: 'github_issue',
+        sourceId: issue.number.toString(),
+        sourceUrl: issue.html_url,
+        repository: repo,
+        labels: issue.labels.map(l => l.name),
+        metadata: {
+            issueNumber: issue.number,
+            author: issue.user.login,
+            createdAt: issue.created_at,
+            polled: true, // Mark as polled vs webhook
+        },
+    };
+}
+/**
+ * Build autonomous prompt from issue
+ */
+function buildPromptFromIssue(issue, repo) {
+    const repoName = repo.split('/').pop();
+    return `You are an autonomous AI developer working on ${repo}.
+
+## Task: ${issue.title}
+
+## Issue Description
+${issue.body || 'No description provided.'}
+
+## Workflow (FOLLOW EXACTLY)
+1. cd ~/openclaw-workdir/${repoName}
+2. git fetch origin && git checkout main && git pull
+3. git checkout -b fix/issue-${issue.number}
+4. Analyze the issue and implement the solution
+5. Run build/tests to verify: pnpm install && pnpm build
+6. Stage changes: git add -A
+7. Commit with message following conventional commits:
+   git commit -m "feat: <description>
+
+Closes #${issue.number}
+
+Co-Authored-By: profClaw <bot@profclaw.dev>"
+8. Push: git push -u origin HEAD
+9. Create PR: gh pr create --title "<title>" --body "Closes #${issue.number}"
+
+## On Errors
+- Fix any build/lint errors before committing
+- If blocked, explain clearly what's wrong
+- Never leave uncommitted changes
+
+## Output
+When done, provide:
+- Summary of changes made
+- Files modified
+- PR URL
+- Any concerns or follow-up items`;
+}
+/**
+ * Get priority from labels
+ */
+function getPriorityFromLabels(labels) {
+    const names = labels.map(l => l.name.toLowerCase());
+    if (names.includes('critical') || names.includes('p0'))
+        return 1;
+    if (names.includes('high') || names.includes('p1'))
+        return 2;
+    if (names.includes('low') || names.includes('p3'))
+        return 4;
+    return 3;
+}
+/**
+ * Poll all configured repos for new issues
+ */
+async function pollForIssues() {
+    if (!GITHUB_TOKEN) {
+        log.debug('No GITHUB_TOKEN configured, skipping poll');
+        return;
+    }
+    if (REPOS_TO_POLL.length === 0) {
+        return; // Silent - no repos configured
+    }
+    log.debug(`Polling ${REPOS_TO_POLL.length} repos`);
+    for (const repo of REPOS_TO_POLL) {
+        const [owner, repoName] = repo.split('/');
+        if (!owner || !repoName)
+            continue;
+        const issues = await fetchOpenIssues(owner, repoName);
+        for (const issue of issues) {
+            // Check if already in queue by sourceId
+            const existingTask = getTask(`github_issue_${issue.number}_${repo}`);
+            if (!existingTask) {
+                log.info(`Found new issue #${issue.number} in ${repo}`, { title: issue.title });
+                try {
+                    const task = await addTask(issueToTask(issue, repo));
+                    log.info(`Created task for issue #${issue.number}`, { taskId: task.id });
+                }
+                catch (error) {
+                    log.error(`Failed to create task for issue #${issue.number}`, error instanceof Error ? error : undefined);
+                }
+            }
+        }
+    }
+}
+/**
+ * Start the issue poller
+ */
+export function startIssuePoller() {
+    if (pollerInterval) {
+        return; // Already running
+    }
+    log.info(`Starting issue poller`, { intervalMs: POLL_INTERVAL });
+    // Run immediately on start
+    pollForIssues().catch((e) => log.error('Poll failed', e instanceof Error ? e : undefined));
+    // Then run at configured interval
+    pollerInterval = setInterval(() => {
+        pollForIssues().catch((e) => log.error('Poll failed', e instanceof Error ? e : undefined));
+    }, POLL_INTERVAL);
+}
+/**
+ * Stop the issue poller
+ */
+export function stopIssuePoller() {
+    if (pollerInterval) {
+        clearInterval(pollerInterval);
+        pollerInterval = null;
+        log.debug('Stopped');
+    }
+}
+//# sourceMappingURL=issue-poller.js.map

package/dist/cron/scheduler.d.ts

@@ -0,0 +1,315 @@
+/**
+ * Scheduled Jobs Scheduler
+ *
+ * Manages cron jobs and scheduled tasks using BullMQ.
+ * Provides a database-backed scheduler that AI agents can use
+ * to schedule recurring tasks.
+ *
+ * Supports:
+ * - Cron expressions (standard 5-field syntax)
+ * - Fixed intervals
+ * - HTTP callbacks
+ * - Tool execution
+ * - Script execution
+ * - Message sending
+ */
+export type JobType = 'http' | 'tool' | 'script' | 'message';
+export type JobStatus = 'active' | 'paused' | 'completed' | 'failed' | 'archived';
+export type RunStatus = 'running' | 'success' | 'error' | 'timeout' | 'cancelled';
+export type EventTriggerType = 'webhook' | 'ticket' | 'file' | 'github';
+export type DeliveryChannelType = 'slack' | 'webhook' | 'email';
+/** Event trigger configuration */
+export interface EventTrigger {
+    type: EventTriggerType;
+    config: Record<string, unknown>;
+}
+/** Delivery channel for job output */
+export interface DeliveryChannel {
+    type: DeliveryChannelType;
+    target: string;
+    onSuccess?: boolean;
+    onFailure?: boolean;
+}
+/** Delivery configuration */
+export interface DeliveryConfig {
+    channels: DeliveryChannel[];
+}
+/** Retry policy configuration */
+export interface RetryPolicy {
+    enabled: boolean;
+    initialDelayMs: number;
+    backoffMultiplier: number;
+    maxDelayMs: number;
+    maxRetries: number;
+}
+export interface ScheduledJob {
+    id: string;
+    name: string;
+    description?: string;
+    cronExpression?: string;
+    intervalMs?: number;
+    runAt?: Date;
+    timezone: string;
+    eventTrigger?: EventTrigger;
+    jobType: JobType;
+    payload: Record<string, unknown>;
+    templateId?: string;
+    labels: string[];
+    delivery?: DeliveryConfig;
+    status: JobStatus;
+    userId?: string;
+    projectId?: string;
+    createdBy: 'human' | 'ai';
+    lastRunAt?: Date;
+    lastRunStatus?: string;
+    lastRunError?: string;
+    nextRunAt?: Date;
+    runCount: number;
+    successCount: number;
+    failureCount: number;
+    maxRuns?: number;
+    maxFailures?: number;
+    retryOnFailure: boolean;
+    retryDelayMs: number;
+    retryBackoffMultiplier: number;
+    retryMaxDelayMs: number;
+    currentRetryCount: number;
+    deleteOnComplete: boolean;
+    createdAt: Date;
+    updatedAt: Date;
+    expiresAt?: Date;
+    archivedAt?: Date;
+}
+export interface CreateJobParams {
+    name: string;
+    description?: string;
+    cronExpression?: string;
+    intervalMs?: number;
+    runAt?: Date;
+    timezone?: string;
+    eventTrigger?: EventTrigger;
+    jobType: JobType;
+    payload: Record<string, unknown>;
+    templateId?: string;
+    labels?: string[];
+    delivery?: DeliveryConfig;
+    userId?: string;
+    projectId?: string;
+    createdBy?: 'human' | 'ai';
+    maxRuns?: number;
+    maxFailures?: number;
+    retryPolicy?: Partial<RetryPolicy>;
+    deleteOnComplete?: boolean;
+    expiresAt?: Date;
+}
+export interface JobRunResult {
+    success: boolean;
+    output?: string;
+    error?: string;
+    durationMs: number;
+}
+export interface HttpJobPayload {
+    url: string;
+    method?: 'GET' | 'POST' | 'PUT' | 'DELETE';
+    headers?: Record<string, string>;
+    body?: unknown;
+    timeout?: number;
+}
+export interface ToolJobPayload {
+    tool: string;
+    params: Record<string, unknown>;
+    conversationId?: string;
+}
+export interface ScriptJobPayload {
+    command: string;
+    args?: string[];
+    workdir?: string;
+    timeout?: number;
+}
+export interface MessageJobPayload {
+    conversationId: string;
+    content: string;
+}
+export declare function getScheduler(): JobScheduler;
+export declare class JobScheduler {
+    private queue;
+    private worker;
+    private isRunning;
+    private redisConfig;
+    /**
+     * Start the scheduler
+     */
+    start(): Promise<void>;
+    /**
+     * Stop the scheduler
+     */
+    stop(): Promise<void>;
+    /**
+     * Load active jobs from database and schedule them
+     */
+    private loadActiveJobs;
+    /**
+     * Create a new scheduled job
+     * Supports: cron expressions, fixed intervals, one-shot (runAt), event triggers
+     */
+    createJob(params: CreateJobParams): Promise<ScheduledJob>;
+    /**
+     * Schedule a one-shot job to run at a specific time
+     */
+    private scheduleOneShotJob;
+    /**
+     * Get a job by ID
+     */
+    getJob(id: string): Promise<ScheduledJob | null>;
+    /**
+     * List all jobs with optional filters
+     */
+    listJobs(filters?: {
+        status?: JobStatus;
+        projectId?: string;
+        userId?: string;
+        jobType?: JobType;
+        limit?: number;
+    }): Promise<ScheduledJob[]>;
+    /**
+     * Update a job
+     */
+    updateJob(id: string, updates: Partial<Pick<CreateJobParams, 'name' | 'description' | 'cronExpression' | 'intervalMs' | 'payload' | 'maxRuns' | 'maxFailures' | 'labels'>> & {
+        status?: 'active' | 'paused';
+    }): Promise<ScheduledJob | null>;
+    /**
+     * Pause a job
+     */
+    pauseJob(id: string): Promise<boolean>;
+    /**
+     * Resume a paused job
+     */
+    resumeJob(id: string): Promise<boolean>;
+    /**
+     * Delete a job
+     */
+    deleteJob(id: string): Promise<boolean>;
+    /**
+     * Archive a job (soft delete)
+     */
+    archiveJob(id: string): Promise<boolean>;
+    /**
+     * Restore an archived job
+     */
+    restoreJob(id: string): Promise<boolean>;
+    /**
+     * Trigger a job immediately (manual run)
+     */
+    triggerJob(id: string): Promise<{
+        runId: string;
+    } | null>;
+    /**
+     * Get job run history
+     */
+    getJobHistory(jobId: string, limit?: number): Promise<Array<{
+        id: string;
+        startedAt: Date;
+        completedAt?: Date;
+        durationMs?: number;
+        status: RunStatus;
+        output?: string;
+        error?: string;
+        triggeredBy: string;
+    }>>;
+    /**
+     * Schedule a job in BullMQ
+     */
+    private scheduleJob;
+    /**
+     * Remove a job from BullMQ queue
+     */
+    private removeFromQueue;
+    /**
+     * Process a job from the queue
+     */
+    private processJob;
+    /**
+     * Execute a scheduled job
+     */
+    private executeJob;
+    /**
+     * Calculate retry delay with exponential backoff
+     */
+    private calculateRetryDelay;
+    /**
+     * Deliver job output to configured channels
+     */
+    private deliverOutput;
+    /**
+     * Deliver output to Slack channel
+     */
+    private deliverToSlack;
+    /**
+     * Deliver output to a webhook URL
+     */
+    private deliverToWebhook;
+    /**
+     * Deliver output via email
+     */
+    private deliverToEmail;
+    /**
+     * Execute an HTTP job
+     */
+    private executeHttpJob;
+    /**
+     * Execute a tool job
+     */
+    private executeToolJob;
+    /**
+     * Execute a script job
+     * Security: Commands are validated against an allowlist and shell execution is disabled
+     */
+    private executeScriptJob;
+    /**
+     * Execute a message job
+     */
+    private executeMessageJob;
+    /**
+     * Calculate next run time from cron or interval
+     */
+    private calculateNextRun;
+    /**
+     * Map database row to ScheduledJob type
+     */
+    private mapToScheduledJob;
+    /**
+     * Trigger a job by event (for event-driven jobs)
+     */
+    triggerByEvent(eventType: EventTriggerType, eventData: Record<string, unknown>): Promise<{
+        triggered: string[];
+    }>;
+    /**
+     * Check if event data matches a trigger config
+     */
+    private matchesEventTrigger;
+}
+export declare const createScheduledJob: (params: CreateJobParams) => Promise<ScheduledJob>;
+export declare const getScheduledJob: (id: string) => Promise<ScheduledJob | null>;
+export declare const listScheduledJobs: (filters?: Parameters<JobScheduler["listJobs"]>[0]) => Promise<ScheduledJob[]>;
+export declare const updateScheduledJob: (id: string, updates: Parameters<JobScheduler["updateJob"]>[1]) => Promise<ScheduledJob | null>;
+export declare const pauseScheduledJob: (id: string) => Promise<boolean>;
+export declare const resumeScheduledJob: (id: string) => Promise<boolean>;
+export declare const deleteScheduledJob: (id: string) => Promise<boolean>;
+export declare const archiveScheduledJob: (id: string) => Promise<boolean>;
+export declare const restoreScheduledJob: (id: string) => Promise<boolean>;
+export declare const triggerScheduledJob: (id: string) => Promise<{
+    runId: string;
+} | null>;
+export declare const getJobRunHistory: (jobId: string, limit?: number) => Promise<{
+    id: string;
+    startedAt: Date;
+    completedAt?: Date;
+    durationMs?: number;
+    status: RunStatus;
+    output?: string;
+    error?: string;
+    triggeredBy: string;
+}[]>;
+export declare const startScheduler: () => Promise<void>;
+export declare const stopScheduler: () => Promise<void>;
+//# sourceMappingURL=scheduler.d.ts.map