@workermill/agent 0.2.2 → 0.3.1

package/dist/cli.js

@@ -13,12 +13,14 @@ import { stopCommand } from "./commands/stop.js";
 import { statusCommand } from "./commands/status.js";
 import { logsCommand } from "./commands/logs.js";
 import { pullCommand } from "./commands/pull.js";
+import { updateCommand } from "./commands/update.js";
 import { getConfigFile } from "./config.js";
+import { AGENT_VERSION } from "./version.js";
 const program = new Command();
 program
     .name("workermill-agent")
     .description("WorkerMill Remote Agent - Run AI workers locally with your Claude Max subscription")
-    .version("0.1.0");
+    .version(AGENT_VERSION);
 program
     .command("setup")
     .description("Interactive setup wizard - configure API key, validate prerequisites, pull worker image")
@@ -45,6 +47,10 @@ program
     .command("pull")
     .description("Pull the latest worker Docker image")
     .action(pullCommand);
+program
+    .command("update")
+    .description("Update the agent to the latest version")
+    .action(updateCommand);
 // If no command given, auto-detect: run setup if no config, otherwise start
 if (process.argv.length <= 2) {
     if (existsSync(getConfigFile())) {

package/dist/commands/update.d.ts

@@ -0,0 +1 @@
+export declare function updateCommand(): Promise<void>;

package/dist/commands/update.js

@@ -0,0 +1,20 @@
+import chalk from "chalk";
+import { AGENT_VERSION } from "../version.js";
+import { selfUpdate } from "../updater.js";
+export async function updateCommand() {
+    console.log();
+    console.log(chalk.bold.cyan("  WorkerMill Agent Update"));
+    console.log(chalk.dim("  ─────────────────────────────────────"));
+    console.log(`  ${chalk.dim("Current version:")} ${AGENT_VERSION}`);
+    console.log();
+    const success = await selfUpdate();
+    if (success) {
+        console.log();
+        console.log(chalk.green("  Update complete. If the agent is running, restart it to use the new version."));
+    }
+    else {
+        console.log();
+        console.error(chalk.red("  Update failed. Try running manually: npm install -g @workermill/agent@latest"));
+        process.exitCode = 1;
+    }
+}

package/dist/index.js

@@ -8,6 +8,8 @@ import chalk from "chalk";
 import { initApi, api } from "./api.js";
 import { startPolling, startHeartbeat } from "./poller.js";
 import { stopAll } from "./spawner.js";
+import { AGENT_VERSION } from "./version.js";
+import { selfUpdate, restartAgent } from "./updater.js";
 export { loadConfig, loadConfigFromFile, validatePrerequisites, getSystemInfo, findClaudePath } from "./config.js";
 /**
  * Start the remote agent with the given config.
@@ -47,10 +49,25 @@ export async function startAgent(config) {
     }
     // Register agent
     try {
-        await api.post("/api/agent/register", {
+        const registerResponse = await api.post("/api/agent/register", {
             agentId: config.agentId,
             maxWorkers: config.maxWorkers,
+            agentVersion: AGENT_VERSION,
         });
+        const { updateAvailable, updateRequired, latestVersion } = registerResponse.data;
+        if (updateRequired) {
+            console.log(chalk.red(`  ⚠ Agent update required (current: ${AGENT_VERSION}, required: ${latestVersion})`));
+            const success = await selfUpdate();
+            if (success) {
+                restartAgent();
+            }
+            else {
+                console.log(chalk.yellow("  Auto-update failed. Run: npm install -g @workermill/agent@latest"));
+            }
+        }
+        else if (updateAvailable) {
+            console.log(chalk.yellow(`  Update available: ${latestVersion} (current: ${AGENT_VERSION}). Run: workermill-agent update`));
+        }
     }
     catch {
         // Registration is best-effort, don't fail startup

package/dist/plan-validator.d.ts

@@ -9,6 +9,7 @@
  * This ensures remote agent plans get the same quality gates as cloud plans,
  * even though the planning prompt runs locally via Claude CLI.
  */
+import { type AIProvider } from "./providers.js";
 export interface PlannedStory {
     id: string;
     title: string;
@@ -76,7 +77,8 @@ export declare function runCriticCli(claudePath: string, model: string, prompt:
 export declare function formatCriticFeedback(critic: CriticResult): string;
 /**
  * Run critic validation on a parsed plan.
+ * Routes to Claude CLI (Anthropic) or HTTP API (other providers).
  * Returns the critic result, or null if critic fails (non-blocking).
  */
-export declare function runCriticValidation(claudePath: string, model: string, prd: string, plan: ExecutionPlan, env: Record<string, string | undefined>, taskLabel: string): Promise<CriticResult | null>;
+export declare function runCriticValidation(claudePath: string, model: string, prd: string, plan: ExecutionPlan, env: Record<string, string | undefined>, taskLabel: string, provider?: AIProvider, providerApiKey?: string): Promise<CriticResult | null>;
 export { AUTO_APPROVAL_THRESHOLD };

package/dist/plan-validator.js

@@ -11,6 +11,7 @@
  */
 import { spawn } from "child_process";
 import chalk from "chalk";
+import { generateText } from "./providers.js";
 // ============================================================================
 // CONSTANTS
 // ============================================================================
@@ -245,13 +246,24 @@ function ts() {
 }
 /**
  * Run critic validation on a parsed plan.
+ * Routes to Claude CLI (Anthropic) or HTTP API (other providers).
  * Returns the critic result, or null if critic fails (non-blocking).
  */
-export async function runCriticValidation(claudePath, model, prd, plan, env, taskLabel) {
+export async function runCriticValidation(claudePath, model, prd, plan, env, taskLabel, provider, providerApiKey) {
     const criticPrompt = buildCriticPrompt(prd, plan);
-    console.log(`${ts()} ${taskLabel} ${chalk.dim("Running critic validation...")}`);
+    const effectiveProvider = provider || "anthropic";
+    console.log(`${ts()} ${taskLabel} ${chalk.dim(`Running critic validation (${effectiveProvider})...`)}`);
     try {
-        const rawCriticOutput = await runCriticCli(claudePath, model, criticPrompt, env);
+        let rawCriticOutput;
+        if (effectiveProvider === "anthropic") {
+            rawCriticOutput = await runCriticCli(claudePath, model, criticPrompt, env);
+        }
+        else {
+            if (!providerApiKey) {
+                throw new Error(`No API key for critic provider "${effectiveProvider}"`);
+            }
+            rawCriticOutput = await generateText(effectiveProvider, model, criticPrompt, providerApiKey, { maxTokens: 4096, temperature: 0.3, timeoutMs: 180_000 });
+        }
         const result = parseCriticResponse(rawCriticOutput);
         const statusIcon = result.score >= AUTO_APPROVAL_THRESHOLD
             ? chalk.green("✓")

package/dist/planner.d.ts

@@ -15,6 +15,7 @@
  * sees the same planning progress as cloud mode.
  */
 import { type AgentConfig } from "./config.js";
+import type { ClaimCredentials } from "./spawner.js";
 export interface PlanningTask {
     id: string;
     summary: string;
@@ -32,4 +33,4 @@ export interface PlanningTask {
  *   6. If critic rejects: re-run planner with feedback (up to MAX_ITERATIONS)
  *   7. After MAX_ITERATIONS without approval: fail the task
  */
-export declare function planTask(task: PlanningTask, config: AgentConfig): Promise<boolean>;
+export declare function planTask(task: PlanningTask, config: AgentConfig, credentials?: ClaimCredentials): Promise<boolean>;

package/dist/planner.js

@@ -19,6 +19,7 @@ import { spawn } from "child_process";
 import { findClaudePath } from "./config.js";
 import { api } from "./api.js";
 import { parseExecutionPlan, applyFileCap, serializePlan, runCriticValidation, formatCriticFeedback, AUTO_APPROVAL_THRESHOLD, } from "./plan-validator.js";
+import { generateText } from "./providers.js";
 /** Max Planner-Critic iterations before giving up */
 const MAX_ITERATIONS = 3;
 /** Timestamp prefix */
@@ -228,6 +229,26 @@ function runClaudeCli(claudePath, model, prompt, env, taskId, startTime) {
         });
     });
 }
+/**
+ * Resolve the API key for a given provider from claim credentials.
+ * For Ollama, returns the base URL instead of an API key.
+ */
+function resolveProviderApiKey(provider, credentials) {
+    if (!credentials)
+        return undefined;
+    switch (provider) {
+        case "anthropic":
+            return credentials.anthropicApiKey;
+        case "openai":
+            return credentials.openaiApiKey;
+        case "google":
+            return credentials.googleApiKey;
+        case "ollama":
+            return credentials.ollamaBaseUrl || "http://localhost:11434";
+        default:
+            return undefined;
+    }
+}
 /**
  * Run planning for a task with Planner-Critic validation loop.
  *
@@ -240,7 +261,7 @@ function runClaudeCli(claudePath, model, prompt, env, taskId, startTime) {
  *   6. If critic rejects: re-run planner with feedback (up to MAX_ITERATIONS)
  *   7. After MAX_ITERATIONS without approval: fail the task
  */
-export async function planTask(task, config) {
+export async function planTask(task, config, credentials) {
     const taskLabel = chalk.cyan(task.id.slice(0, 8));
     console.log(`${ts()} ${taskLabel} Fetching planning prompt...`);
     await postLog(task.id, `${PREFIX} Fetching planning prompt from cloud API...`);
@@ -248,11 +269,15 @@ export async function planTask(task, config) {
     const promptResponse = await api.get("/api/agent/planning-prompt", {
         params: { taskId: task.id },
     });
-    const { prompt: basePrompt, model } = promptResponse.data;
+    const { prompt: basePrompt, model, provider: planningProvider } = promptResponse.data;
     const cliModel = model || "sonnet";
+    const provider = (planningProvider || "anthropic");
+    const isAnthropicPlanning = provider === "anthropic";
     const claudePath = process.env.CLAUDE_CLI_PATH || findClaudePath() || "claude";
     const cleanEnv = { ...process.env };
     delete cleanEnv.CLAUDE_CODE_OAUTH_TOKEN;
+    // Resolve provider API key for non-Anthropic planning
+    const providerApiKey = resolveProviderApiKey(provider, credentials);
     const startTime = Date.now();
     // PRD for critic validation: use task description, fall back to summary
     const prd = task.description || task.summary;
@@ -265,18 +290,28 @@ export async function planTask(task, config) {
     let totalFileCapTruncations = 0;
     for (let iteration = 1; iteration <= MAX_ITERATIONS; iteration++) {
         const iterLabel = MAX_ITERATIONS > 1 ? ` (attempt ${iteration}/${MAX_ITERATIONS})` : "";
+        const providerLabel = `${provider}/${cliModel}`;
         if (iteration > 1) {
-            console.log(`${ts()} ${taskLabel} Running Claude CLI${iterLabel} ${chalk.dim(`(model: ${chalk.yellow(cliModel)})`)}`);
-            await postLog(task.id, `${PREFIX} Re-planning${iterLabel} using anthropic/${cliModel}`);
+            console.log(`${ts()} ${taskLabel} Running planner${iterLabel} ${chalk.dim(`(${chalk.yellow(providerLabel)})`)}`);
+            await postLog(task.id, `${PREFIX} Re-planning${iterLabel} using ${providerLabel}`);
         }
         else {
-            console.log(`${ts()} ${taskLabel} Running Claude CLI ${chalk.dim(`(model: ${chalk.yellow(cliModel)})`)}`);
-            await postLog(task.id, `${PREFIX} Starting planning agent using anthropic/${cliModel}`);
+            console.log(`${ts()} ${taskLabel} Running planner ${chalk.dim(`(${chalk.yellow(providerLabel)})`)}`);
+            await postLog(task.id, `${PREFIX} Starting planning agent using ${providerLabel}`);
         }
-        // 2a. Run Claude CLI to generate plan
+        // 2a. Generate plan via Claude CLI (Anthropic) or HTTP API (other providers)
         let rawOutput;
         try {
-            rawOutput = await runClaudeCli(claudePath, cliModel, currentPrompt, cleanEnv, task.id, startTime);
+            if (isAnthropicPlanning) {
+                rawOutput = await runClaudeCli(claudePath, cliModel, currentPrompt, cleanEnv, task.id, startTime);
+            }
+            else {
+                if (!providerApiKey) {
+                    throw new Error(`No API key available for provider "${provider}". Configure it in Settings > Integrations.`);
+                }
+                await postProgress(task.id, "generating_plan", 0, "Generating plan via API...", 0, 0);
+                rawOutput = await generateText(provider, cliModel, currentPrompt, providerApiKey);
+            }
         }
         catch (error) {
             const elapsed = Math.round((Date.now() - startTime) / 1000);
@@ -313,7 +348,7 @@ export async function planTask(task, config) {
         console.log(`${ts()} ${taskLabel} Plan: ${chalk.bold(plan.stories.length)} stories`);
         await postLog(task.id, `${PREFIX} Plan generated: ${plan.stories.length} stories (${formatElapsed(elapsed)}). Running critic validation...`);
         // 2d. Run critic validation
-        const criticResult = await runCriticValidation(claudePath, cliModel, prd, plan, cleanEnv, taskLabel);
+        const criticResult = await runCriticValidation(claudePath, cliModel, prd, plan, cleanEnv, taskLabel, provider, providerApiKey);
         // Track best plan across iterations
         if (criticResult && criticResult.score > bestScore) {
             bestPlan = plan;

package/dist/poller.js

@@ -7,11 +7,16 @@
 import chalk from "chalk";
 import { api } from "./api.js";
 import { planTask } from "./planner.js";
-import { spawnWorker, getActiveCount, getActiveTaskIds, stopTask } from "./spawner.js";
+import { spawnWorker, 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();
 // 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());
@@ -36,6 +41,9 @@ async function getOrgConfig() {
  * 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 },
@@ -68,7 +76,8 @@ async function pollOnce(config) {
  * Handle a task in "planning" status.
  */
 async function handlePlanningTask(task, config) {
-    // Claim the task
+    // Claim the task (also returns org credentials for provider API keys)
+    let credentials;
     try {
         const claimResponse = await api.post("/api/agent/claim", {
             taskId: task.id,
@@ -77,6 +86,7 @@ async function handlePlanningTask(task, config) {
         if (!claimResponse.data.claimed) {
             return; // Another agent or cloud orchestrator claimed it
         }
+        credentials = claimResponse.data.credentials;
     }
     catch {
         return;
@@ -86,7 +96,7 @@ async function handlePlanningTask(task, config) {
     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)
+    planTask(task, config, credentials)
         .then((success) => {
         if (success) {
             console.log(`${ts()} ${chalk.green("✓")} Planning complete for ${taskLabel}`);
@@ -174,6 +184,7 @@ export function startHeartbeat(config) {
             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;
@@ -182,6 +193,25 @@ export function startHeartbeat(config) {
                     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

package/dist/providers.d.ts

@@ -0,0 +1,18 @@
+/**
+ * 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

@@ -0,0 +1,118 @@
+/**
+ * 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

@@ -14,6 +14,7 @@ export interface SpawnableTask {
     description: string | null;
     jiraIssueKey: string | null;
     workerModel: string;
+    workerProvider?: string;
     githubRepo: string;
     scmProvider: string;
     skipManagerReview?: boolean;
@@ -34,6 +35,10 @@ export interface ClaimCredentials {
     customerAwsRegion?: string;
     issueTrackerProvider?: string;
     bitbucketEmail?: string;
+    anthropicApiKey?: string;
+    openaiApiKey?: string;
+    googleApiKey?: string;
+    ollamaBaseUrl?: string;
 }
 /**
  * Spawn a Docker worker container for a task.

package/dist/spawner.js

@@ -193,8 +193,13 @@ export async function spawnWorker(task, config, orgConfig, credentials) {
         BITBUCKET_EMAIL: credentials?.bitbucketEmail || "",
         // Task notes from dashboard
         TASK_NOTES: task.taskNotes || "",
-        // Anthropic API key (if available)
-        ANTHROPIC_API_KEY: process.env.ANTHROPIC_API_KEY || "",
+        // AI provider configuration
+        ANTHROPIC_API_KEY: credentials?.anthropicApiKey || process.env.ANTHROPIC_API_KEY || "",
+        WORKER_PROVIDER: task.workerProvider || "anthropic",
+        OPENAI_API_KEY: credentials?.openaiApiKey || "",
+        GOOGLE_API_KEY: credentials?.googleApiKey || "",
+        GOOGLE_GENERATIVE_AI_API_KEY: credentials?.googleApiKey || "",
+        OLLAMA_HOST: credentials?.ollamaBaseUrl || "",
         // Resilience settings from org config
         BLOCKER_MAX_AUTO_RETRIES: String(orgConfig.blockerMaxAutoRetries ?? 3),
         BLOCKER_AUTO_RETRY_ENABLED: orgConfig.blockerAutoRetryEnabled !== false ? "true" : "false",

package/dist/updater.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Run `npm install -g @workermill/agent@latest` and return whether it succeeded.
+ */
+export declare function selfUpdate(): Promise<boolean>;
+/**
+ * Restart the current process by spawning a new one and exiting.
+ */
+export declare function restartAgent(): never;

package/dist/updater.js

@@ -0,0 +1,40 @@
+import { spawn } from "child_process";
+import chalk from "chalk";
+/**
+ * Run `npm install -g @workermill/agent@latest` and return whether it succeeded.
+ */
+export async function selfUpdate() {
+    console.log(chalk.cyan("  Updating @workermill/agent..."));
+    return new Promise((resolve) => {
+        const child = spawn("npm", ["install", "-g", "@workermill/agent@latest"], {
+            stdio: "inherit",
+            shell: true,
+        });
+        child.on("error", (err) => {
+            console.error(chalk.red(`  Update failed: ${err.message}`));
+            resolve(false);
+        });
+        child.on("close", (code) => {
+            if (code === 0) {
+                console.log(chalk.green("  Update successful."));
+                resolve(true);
+            }
+            else {
+                console.error(chalk.red(`  Update failed with exit code ${code}`));
+                resolve(false);
+            }
+        });
+    });
+}
+/**
+ * Restart the current process by spawning a new one and exiting.
+ */
+export function restartAgent() {
+    console.log(chalk.cyan("  Restarting agent..."));
+    const child = spawn(process.argv[0], process.argv.slice(1), {
+        stdio: "inherit",
+        detached: true,
+    });
+    child.unref();
+    process.exit(0);
+}

package/dist/version.d.ts

@@ -0,0 +1 @@
+export declare const AGENT_VERSION: string;

package/dist/version.js

@@ -0,0 +1,4 @@
+import { createRequire } from "module";
+const require = createRequire(import.meta.url);
+const pkg = require("../package.json");
+export const AGENT_VERSION = pkg.version;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@workermill/agent",
-  "version": "0.2.2",
+  "version": "0.3.1",
   "description": "WorkerMill Remote Agent - Run AI workers locally with your Claude Max subscription",
   "type": "module",
   "main": "./dist/index.js",