@workermill/agent 0.8.8 → 0.8.10

package/dist/poller.d.ts

@@ -1,20 +0,0 @@
-/**
- * Remote Agent Poller
- *
- * Main poll loop: every N seconds, query the cloud API for tasks,
- * dispatch to planner or spawner based on task status.
- */
-import type { AgentConfig } from "./config.js";
-/**
- * Stop all polling and heartbeat loops.
- * Called during graceful shutdown to prevent the event loop from staying alive.
- */
-export declare function stopPolling(): void;
-/**
- * Start the poll loop.
- */
-export declare function startPolling(config: AgentConfig): void;
-/**
- * Start the heartbeat loop.
- */
-export declare function startHeartbeat(config: AgentConfig): void;

package/dist/poller.js

@@ -1,346 +0,0 @@
-/**
- * Remote Agent Poller
- *
- * Main poll loop: every N seconds, query the cloud API for tasks,
- * dispatch to planner or spawner based on task status.
- */
-import chalk from "chalk";
-import { api } from "./api.js";
-import { planTask } from "./planner.js";
-import { spawnWorker, spawnManagerWorker, getActiveCount, getActiveTaskIds, stopTask, } from "./spawner.js";
-import { AGENT_VERSION } from "./version.js";
-import { selfUpdate, restartAgent } from "./updater.js";
-// Track tasks currently being planned (to avoid double-dispatching)
-const planningInProgress = new Set();
-// Track manager tasks in progress (to avoid double-dispatching)
-const managerInProgress = new Set();
-// Cached org config
-let orgConfig = null;
-// Flags to avoid spamming update notices every heartbeat
-let updateNoticePrinted = false;
-let updateInProgress = false;
-/** Timestamp prefix for log lines */
-function ts() {
-    return chalk.dim(new Date().toLocaleTimeString());
-}
-/**
- * Fetch org config from the cloud API (cached).
- */
-async function getOrgConfig() {
-    if (orgConfig)
-        return orgConfig;
-    try {
-        const response = await api.get("/api/agent/config");
-        orgConfig = response.data;
-        return orgConfig;
-    }
-    catch (error) {
-        console.error(`${ts()} ${chalk.red("✗")} Failed to fetch org config`);
-        return {};
-    }
-}
-/**
- * Run a single poll iteration.
- */
-async function pollOnce(config) {
-    // Skip polling when a required update is in progress
-    if (updateInProgress)
-        return;
-    try {
-        const response = await api.get("/api/agent/poll", {
-            params: { agentId: config.agentId },
-        });
-        const tasks = response.data.tasks;
-        if (tasks.length === 0)
-            return;
-        for (const task of tasks) {
-            if (task.status === "planning" && !planningInProgress.has(task.id)) {
-                // Claim and plan
-                await handlePlanningTask(task, config);
-            }
-            else if (task.status === "queued") {
-                // Claim and spawn
-                await handleQueuedTask(task, config);
-            }
-        }
-        // Handle manager tasks (log analysis, PR review)
-        const managerTasks = response.data.managerTasks;
-        if (managerTasks && managerTasks.length > 0) {
-            for (const mt of managerTasks) {
-                if (!managerInProgress.has(mt.id)) {
-                    await handleManagerTask(mt, config);
-                }
-            }
-        }
-    }
-    catch (error) {
-        const err = error;
-        const busy = planningInProgress.size > 0 || getActiveCount() > 0 || managerInProgress.size > 0;
-        if (err.response?.status === 401) {
-            if (!busy) {
-                console.error(`${ts()} ${chalk.red("✗")} Authentication failed. Check your API key.`);
-            }
-            // Silent when busy — transient DB pool exhaustion on server
-        }
-        else if (!busy) {
-            console.warn(`${ts()} ${chalk.yellow("⚠")} Poll error: ${err.message || String(error)}`);
-        }
-        // Silent when busy — expected during heavy planning/execution
-    }
-}
-/**
- * Handle a task in "planning" status.
- */
-async function handlePlanningTask(task, config) {
-    // Claim the task (also returns org credentials for provider API keys)
-    let credentials;
-    let claimedTask;
-    try {
-        const claimResponse = await api.post("/api/agent/claim", {
-            taskId: task.id,
-            agentId: config.agentId,
-        });
-        if (!claimResponse.data.claimed) {
-            return; // Another agent or cloud orchestrator claimed it
-        }
-        credentials = claimResponse.data.credentials;
-        claimedTask = claimResponse.data.task;
-    }
-    catch {
-        return;
-    }
-    const taskLabel = chalk.cyan(task.id.slice(0, 8));
-    // Check if this is a retry with an existing plan (resume scenario).
-    // The API preserves planJson/executionPlanV2 on retry when stories exist,
-    // so we can skip planning entirely and transition straight to queued.
-    const isRetryWithPlan = claimedTask &&
-        (claimedTask.retryCount ?? 0) > 0 &&
-        claimedTask.executionPlanV2 != null;
-    if (isRetryWithPlan) {
-        console.log();
-        console.log(`${ts()} ${chalk.magenta("◆ RESUME")} ${taskLabel} ${task.summary.substring(0, 60)}`);
-        console.log(`${ts()} ${taskLabel} Retry #${claimedTask.retryCount} with existing plan — skipping planning`);
-        planningInProgress.add(task.id);
-        // Tell the API to resume with the existing plan (planning → queued)
-        try {
-            await api.post("/api/agent/resume-plan", {
-                taskId: task.id,
-                agentId: config.agentId,
-            });
-            console.log(`${ts()} ${taskLabel} ${chalk.green("✓")} Resumed with existing plan → ${chalk.green("queued")}`);
-        }
-        catch (err) {
-            const error = err;
-            const detail = error.response?.data?.error || error.message || String(err);
-            console.error(`${ts()} ${taskLabel} ${chalk.red("✗")} Resume failed: ${detail}`);
-        }
-        planningInProgress.delete(task.id);
-        return;
-    }
-    console.log();
-    console.log(`${ts()} ${chalk.magenta("◆ PLANNING")} ${taskLabel} ${task.summary.substring(0, 60)}`);
-    planningInProgress.add(task.id);
-    // Run planning asynchronously (don't block the poll loop)
-    planTask(task, config, credentials)
-        .then((success) => {
-        if (success) {
-            console.log(`${ts()} ${chalk.green("✓")} Planning complete for ${taskLabel}`);
-        }
-        else {
-            console.log(`${ts()} ${chalk.red("✗")} Planning failed for ${taskLabel}`);
-        }
-    })
-        .catch((err) => console.error(`${ts()} ${chalk.red("✗")} Planning error for ${taskLabel}:`, err.message || err))
-        .finally(() => planningInProgress.delete(task.id));
-}
-/**
- * Handle a task in "queued" status.
- */
-async function handleQueuedTask(task, config) {
-    // Check concurrency limit
-    const activeCount = getActiveCount();
-    if (activeCount >= config.maxWorkers) {
-        return; // At capacity
-    }
-    // Claim the task
-    let claimData;
-    try {
-        const claimResponse = await api.post("/api/agent/claim", {
-            taskId: task.id,
-            agentId: config.agentId,
-        });
-        claimData = claimResponse.data;
-        if (!claimData.claimed) {
-            return;
-        }
-    }
-    catch {
-        return;
-    }
-    // Report started
-    try {
-        await api.post("/api/agent/started", {
-            taskId: task.id,
-            agentId: config.agentId,
-        });
-    }
-    catch (err) {
-        const taskLabel = chalk.cyan(task.id.slice(0, 8));
-        console.warn(`${ts()} ${chalk.yellow("⚠")} Failed to report started for ${taskLabel}`);
-    }
-    const taskLabel = chalk.cyan(task.id.slice(0, 8));
-    console.log();
-    console.log(`${ts()} ${chalk.blue("▶ EXECUTING")} ${taskLabel} ${task.summary.substring(0, 60)}`);
-    const oc = await getOrgConfig();
-    const spawnableTask = claimData.task || {
-        id: task.id,
-        summary: task.summary,
-        description: task.description,
-        jiraIssueKey: task.jiraIssueKey,
-        workerModel: task.workerModel,
-        workerProvider: task.workerProvider,
-        githubRepo: task.githubRepo,
-        scmProvider: task.scmProvider,
-        skipManagerReview: task.skipManagerReview,
-        deploymentEnabled: task.deploymentEnabled,
-        improvementEnabled: task.improvementEnabled,
-        qualityGateBypass: task.qualityGateBypass,
-        standardSdkMode: task.standardSdkMode,
-        parentTaskId: task.parentTaskId,
-        taskNotes: task.taskNotes,
-        githubPrUrl: task.githubPrUrl,
-        githubPrNumber: task.githubPrNumber,
-        executionPlanV2: task.executionPlanV2,
-        jiraFields: task.jiraFields || {},
-    };
-    // Pass org credentials from the claim response to the container
-    const credentials = claimData.credentials;
-    // Spawn asynchronously (don't block the poll loop)
-    spawnWorker(spawnableTask, config, oc, credentials).catch((err) => console.error(`${ts()} ${chalk.red("✗")} Spawn failed for ${taskLabel}:`, err.message || err));
-}
-/**
- * Handle a manager task (log analysis or PR review).
- */
-async function handleManagerTask(task, config) {
-    const taskLabel = chalk.cyan(task.id.slice(0, 8));
-    managerInProgress.add(task.id);
-    // Claim the manager task
-    try {
-        const claimResponse = await api.post("/api/agent/claim-manager", {
-            taskId: task.id,
-            agentId: config.agentId,
-            action: task.managerAction,
-        });
-        if (!claimResponse.data.claimed) {
-            managerInProgress.delete(task.id);
-            return; // Another agent or cloud ECS claimed it
-        }
-        const claimedTask = claimResponse.data.task;
-        const credentials = claimResponse.data.credentials || {};
-        const actionLabel = task.managerAction === "analyze_logs"
-            ? chalk.yellow("LOG ANALYSIS")
-            : chalk.yellow("PR REVIEW");
-        console.log();
-        console.log(`${ts()} ${chalk.magenta("◆ MANAGER")} ${actionLabel} ${taskLabel} ${task.summary.substring(0, 60)}`);
-        const managerTask = {
-            id: task.id,
-            summary: claimedTask?.summary || task.summary,
-            description: claimedTask?.description || task.description,
-            jiraIssueKey: claimedTask?.jiraIssueKey || task.jiraIssueKey,
-            githubRepo: claimedTask?.githubRepo || task.githubRepo,
-            scmProvider: claimedTask?.scmProvider || task.scmProvider,
-            githubPrUrl: claimedTask?.githubPrUrl || task.githubPrUrl,
-            githubPrNumber: claimedTask?.githubPrNumber || task.githubPrNumber,
-            managerAction: task.managerAction,
-        };
-        // Spawn asynchronously (don't block the poll loop)
-        spawnManagerWorker(managerTask, config, credentials)
-            .then(() => {
-            console.log(`${ts()} ${taskLabel} ${chalk.magenta("MGR")} ${chalk.green("✓")} Manager ${task.managerAction} dispatched`);
-        })
-            .catch((err) => {
-            console.error(`${ts()} ${taskLabel} ${chalk.magenta("MGR")} ${chalk.red("✗")} Manager spawn failed:`, err.message || err);
-        })
-            .finally(() => managerInProgress.delete(task.id));
-    }
-    catch (err) {
-        managerInProgress.delete(task.id);
-        const error = err;
-        console.error(`${ts()} ${taskLabel} ${chalk.red("✗")} Failed to claim manager task:`, error.message || String(err));
-    }
-}
-// Store interval IDs so they can be cleared on shutdown
-let pollIntervalId = null;
-let heartbeatIntervalId = null;
-/**
- * Stop all polling and heartbeat loops.
- * Called during graceful shutdown to prevent the event loop from staying alive.
- */
-export function stopPolling() {
-    if (pollIntervalId) {
-        clearInterval(pollIntervalId);
-        pollIntervalId = null;
-    }
-    if (heartbeatIntervalId) {
-        clearInterval(heartbeatIntervalId);
-        heartbeatIntervalId = null;
-    }
-}
-/**
- * Start the poll loop.
- */
-export function startPolling(config) {
-    console.log(`  ${chalk.dim("Polling every")} ${config.pollIntervalMs / 1000}s ${chalk.dim("· waiting for tasks...")}`);
-    // Initial poll
-    pollOnce(config);
-    // Recurring poll
-    pollIntervalId = setInterval(() => pollOnce(config), config.pollIntervalMs);
-}
-/**
- * Start the heartbeat loop.
- */
-export function startHeartbeat(config) {
-    heartbeatIntervalId = setInterval(async () => {
-        // Include BOTH running containers AND tasks being planned/managed
-        const containerTaskIds = getActiveTaskIds();
-        const planningTaskIds = Array.from(planningInProgress);
-        const managerTaskIds = Array.from(managerInProgress);
-        const activeTaskIds = [...containerTaskIds, ...planningTaskIds, ...managerTaskIds];
-        try {
-            const response = await api.post("/api/agent/heartbeat", {
-                agentId: config.agentId,
-                activeTasks: activeTaskIds,
-                agentVersion: AGENT_VERSION,
-            });
-            // Stop containers for tasks cancelled via the cloud dashboard
-            const cancelledTasks = response.data?.cancelledTasks;
-            if (cancelledTasks && cancelledTasks.length > 0) {
-                for (const taskId of cancelledTasks) {
-                    stopTask(taskId);
-                }
-            }
-            // Handle update signals from server
-            const { updateAvailable, updateRequired, latestVersion } = response.data ?? {};
-            if (updateRequired && !updateInProgress) {
-                updateInProgress = true;
-                console.log(`${ts()} ${chalk.red("⚠ Agent update required")} (current: ${AGENT_VERSION}, required: ${latestVersion})`);
-                console.log(`${ts()} ${chalk.yellow("Refusing new tasks until updated.")}`);
-                const success = await selfUpdate();
-                if (success) {
-                    restartAgent();
-                }
-                else {
-                    console.log(`${ts()} ${chalk.red("Auto-update failed.")} Run: npm install -g @workermill/agent@latest`);
-                    updateInProgress = false;
-                }
-            }
-            else if (updateAvailable && !updateNoticePrinted && !updateRequired) {
-                updateNoticePrinted = true;
-                console.log(`${ts()} ${chalk.yellow(`Update available: ${latestVersion}`)} (current: ${AGENT_VERSION}). Run: workermill-agent update`);
-            }
-        }
-        catch {
-            // Heartbeat failures are non-critical
-        }
-    }, config.heartbeatIntervalMs);
-}

package/dist/providers.d.ts

@@ -1,18 +0,0 @@
-/**
- * Lightweight HTTP wrappers for text generation across AI providers.
- *
- * Used for planning and critic stages when the org's provider is not Anthropic.
- * No heavy SDK dependencies — uses the existing axios dependency for HTTP calls.
- * Streaming is not needed (planning/critic are text-only, result matters).
- */
-export type AIProvider = "anthropic" | "openai" | "google" | "ollama";
-export interface GenerateTextOptions {
-    maxTokens?: number;
-    temperature?: number;
-    timeoutMs?: number;
-}
-/**
- * Generate text from any supported AI provider via direct HTTP API calls.
- * Returns the raw text response.
- */
-export declare function generateText(provider: AIProvider, model: string, prompt: string, apiKey: string, options?: GenerateTextOptions): Promise<string>;

package/dist/providers.js

@@ -1,118 +0,0 @@
-/**
- * Lightweight HTTP wrappers for text generation across AI providers.
- *
- * Used for planning and critic stages when the org's provider is not Anthropic.
- * No heavy SDK dependencies — uses the existing axios dependency for HTTP calls.
- * Streaming is not needed (planning/critic are text-only, result matters).
- */
-import axios from "axios";
-const DEFAULT_MAX_TOKENS = 16384;
-const DEFAULT_TIMEOUT_MS = 600_000; // 10 minutes (matches Claude CLI timeout)
-/**
- * Generate text from any supported AI provider via direct HTTP API calls.
- * Returns the raw text response.
- */
-export async function generateText(provider, model, prompt, apiKey, options) {
-    const maxTokens = options?.maxTokens ?? DEFAULT_MAX_TOKENS;
-    const temperature = options?.temperature ?? 0.7;
-    const timeoutMs = options?.timeoutMs ?? DEFAULT_TIMEOUT_MS;
-    switch (provider) {
-        case "anthropic":
-            return generateAnthropic(model, prompt, apiKey, maxTokens, temperature, timeoutMs);
-        case "openai":
-            return generateOpenAI(model, prompt, apiKey, maxTokens, temperature, timeoutMs);
-        case "google":
-            return generateGoogle(model, prompt, apiKey, maxTokens, temperature, timeoutMs);
-        case "ollama":
-            return generateOllama(model, prompt, apiKey, maxTokens, temperature, timeoutMs);
-        default:
-            throw new Error(`Unsupported AI provider: ${provider}`);
-    }
-}
-/**
- * Anthropic Messages API (for orgs with API key, not CLI).
- */
-async function generateAnthropic(model, prompt, apiKey, maxTokens, temperature, timeoutMs) {
-    const response = await axios.post("https://api.anthropic.com/v1/messages", {
-        model,
-        max_tokens: maxTokens,
-        temperature,
-        messages: [{ role: "user", content: prompt }],
-    }, {
-        headers: {
-            "x-api-key": apiKey,
-            "anthropic-version": "2023-06-01",
-            "Content-Type": "application/json",
-        },
-        timeout: timeoutMs,
-    });
-    const content = response.data?.content;
-    if (Array.isArray(content)) {
-        return content
-            .filter((block) => block.type === "text")
-            .map((block) => block.text)
-            .join("");
-    }
-    throw new Error("Unexpected Anthropic API response format");
-}
-/**
- * OpenAI Chat Completions API.
- */
-async function generateOpenAI(model, prompt, apiKey, maxTokens, temperature, timeoutMs) {
-    const response = await axios.post("https://api.openai.com/v1/chat/completions", {
-        model,
-        max_tokens: maxTokens,
-        temperature,
-        messages: [{ role: "user", content: prompt }],
-    }, {
-        headers: {
-            Authorization: `Bearer ${apiKey}`,
-            "Content-Type": "application/json",
-        },
-        timeout: timeoutMs,
-    });
-    const message = response.data?.choices?.[0]?.message;
-    if (message?.content)
-        return message.content;
-    throw new Error("Unexpected OpenAI API response format");
-}
-/**
- * Google Generative AI (Gemini) API.
- */
-async function generateGoogle(model, prompt, apiKey, maxTokens, temperature, timeoutMs) {
-    const response = await axios.post(`https://generativelanguage.googleapis.com/v1beta/models/${model}:generateContent?key=${apiKey}`, {
-        contents: [{ parts: [{ text: prompt }] }],
-        generationConfig: {
-            maxOutputTokens: maxTokens,
-            temperature,
-        },
-    }, {
-        headers: { "Content-Type": "application/json" },
-        timeout: timeoutMs,
-    });
-    const candidate = response.data?.candidates?.[0];
-    const text = candidate?.content?.parts?.[0]?.text;
-    if (text)
-        return text;
-    throw new Error("Unexpected Google AI API response format");
-}
-/**
- * Ollama Generate API (self-hosted).
- * `apiKey` is used as the Ollama base URL (e.g. "http://localhost:11434").
- */
-async function generateOllama(model, prompt, ollamaHost, _maxTokens, temperature, timeoutMs) {
-    const baseUrl = ollamaHost || "http://localhost:11434";
-    const response = await axios.post(`${baseUrl}/api/generate`, {
-        model,
-        prompt,
-        stream: false,
-        options: { temperature },
-    }, {
-        headers: { "Content-Type": "application/json" },
-        timeout: timeoutMs,
-    });
-    const text = response.data?.response;
-    if (text)
-        return text;
-    throw new Error("Unexpected Ollama API response format");
-}

package/dist/spawner.d.ts

@@ -1,116 +0,0 @@
-/**
- * Remote Agent Spawner
- *
- * Spawns Docker worker containers that talk directly to the cloud WorkerMill API.
- * Extracted from api/src/services/local-epic-spawner.ts with key differences:
- *   - API_BASE_URL points to cloud (https://workermill.com)
- *   - ORG_API_KEY is the real org API key
- *   - Container logs stream to cloud dashboard via SSE
- */
-import type { AgentConfig } from "./config.js";
-export interface SpawnableTask {
-    id: string;
-    orgId?: string;
-    summary: string;
-    description: string | null;
-    jiraIssueKey: string | null;
-    workerModel: string;
-    workerProvider?: string;
-    workerPersona?: string;
-    githubRepo: string;
-    scmProvider: string;
-    skipManagerReview?: boolean;
-    executionPlanV2: unknown;
-    jiraFields: Record<string, unknown>;
-    taskNotes?: string;
-    deploymentEnabled?: boolean;
-    improvementEnabled?: boolean;
-    qualityGateBypass?: boolean;
-    standardSdkMode?: boolean;
-    parentTaskId?: string;
-    githubPrUrl?: string;
-    githubPrNumber?: number;
-    retryCount?: number;
-    pipelineVersion?: string;
-}
-/** Org credentials returned by /api/agent/claim */
-export interface ClaimCredentials {
-    jiraBaseUrl?: string;
-    jiraEmail?: string;
-    jiraApiToken?: string;
-    linearApiKey?: string;
-    managerProvider?: string;
-    managerModelId?: string;
-    customerAwsAccessKeyId?: string;
-    customerAwsSecretAccessKey?: string;
-    customerAwsRegion?: string;
-    customerAwsRoleArn?: string;
-    customerAwsExternalId?: string;
-    issueTrackerProvider?: string;
-    bitbucketEmail?: string;
-    githubReviewerToken?: string;
-    scmBaseUrl?: string;
-    ollamaContextWindow?: number;
-    scmToken?: string;
-    githubToken?: string;
-    bitbucketUsername?: string;
-    anthropicApiKey?: string;
-    openaiApiKey?: string;
-    googleApiKey?: string;
-    ollamaBaseUrl?: string;
-    vllmBaseUrl?: string;
-}
-/**
- * Spawn a Docker worker container for a task.
- */
-export declare function spawnWorker(task: SpawnableTask, config: AgentConfig, orgConfig: Record<string, unknown>, credentials?: ClaimCredentials): Promise<void>;
-/**
- * Get count of actively running containers.
- */
-export declare function getActiveCount(): number;
-/**
- * Get IDs of all active tasks.
- */
-export declare function getActiveTaskIds(): string[];
-/**
- * Stop a specific task's container by task ID.
- */
-export declare function stopTask(taskId: string): void;
-/**
- * Stop all running containers.
- */
-export declare function stopAll(): Promise<void>;
-/** Manager task returned by the poll endpoint */
-export interface ManagerTask {
-    id: string;
-    summary: string;
-    description: string | null;
-    jiraIssueKey: string | null;
-    githubRepo: string;
-    scmProvider: string;
-    githubPrUrl?: string;
-    githubPrNumber?: number;
-    managerAction: "analyze_logs" | "review_pr";
-}
-/** Credentials for manager tasks (subset of ClaimCredentials) */
-export interface ManagerCredentials {
-    managerProvider?: string;
-    managerModelId?: string;
-    anthropicApiKey?: string;
-    openaiApiKey?: string;
-    googleApiKey?: string;
-    ollamaBaseUrl?: string;
-    jiraBaseUrl?: string;
-    jiraEmail?: string;
-    jiraApiToken?: string;
-    linearApiKey?: string;
-    issueTrackerProvider?: string;
-    scmToken?: string;
-    githubToken?: string;
-    bitbucketUsername?: string;
-}
-/**
- * Spawn a manager Docker container for PR review or log analysis.
- * Uses the same worker image but overrides the entrypoint to manager-entrypoint.sh.
- */
-export declare function spawnManagerWorker(task: ManagerTask, config: AgentConfig, credentials?: ManagerCredentials): Promise<void>;