@workermill/agent 0.2.1 → 0.3.0

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/planner.js

@@ -260,6 +260,9 @@ export async function planTask(task, config) {
     let currentPrompt = basePrompt;
     let bestPlan = null;
     let bestScore = 0;
+    // Track critic history across iterations for analytics
+    const criticHistory = [];
+    let totalFileCapTruncations = 0;
     for (let iteration = 1; iteration <= MAX_ITERATIONS; iteration++) {
         const iterLabel = MAX_ITERATIONS > 1 ? ` (attempt ${iteration}/${MAX_ITERATIONS})` : "";
         if (iteration > 1) {
@@ -299,6 +302,7 @@ export async function planTask(task, config) {
         // 2c. Apply file cap (max 5 files per story)
         const { truncatedCount, details } = applyFileCap(plan);
         if (truncatedCount > 0) {
+            totalFileCapTruncations += truncatedCount;
             const msg = `${PREFIX} File cap applied: ${truncatedCount} stories truncated to max 5 targetFiles`;
             console.log(`${ts()} ${taskLabel} ${chalk.yellow("⚠")} ${msg}`);
             await postLog(task.id, msg);
@@ -319,13 +323,25 @@ export async function planTask(task, config) {
             // Critic failed entirely — use this plan as fallback
             bestPlan = plan;
         }
+        // Record critic history for this iteration
+        if (criticResult) {
+            criticHistory.push({
+                iteration,
+                score: criticResult.score,
+                approved: criticResult.approved || criticResult.score >= AUTO_APPROVAL_THRESHOLD,
+                risks: criticResult.risks,
+                suggestions: criticResult.suggestions,
+                filesCapApplied: truncatedCount > 0 ? truncatedCount : undefined,
+            });
+        }
         // 2e. Check critic result
         if (!criticResult) {
             // Critic failed (timeout, parse error, etc.) — post plan without critic gate
             const msg = `${PREFIX} Critic validation failed — posting plan without critic score`;
             console.log(`${ts()} ${taskLabel} ${chalk.yellow("⚠")} ${msg}`);
             await postLog(task.id, msg);
-            return await postValidatedPlan(task.id, plan, config.agentId, taskLabel, elapsed);
+            const planningDurationMs = Date.now() - startTime;
+            return await postValidatedPlan(task.id, plan, config.agentId, taskLabel, elapsed, undefined, undefined, criticHistory, totalFileCapTruncations, planningDurationMs, iteration);
         }
         if (criticResult.approved || criticResult.score >= AUTO_APPROVAL_THRESHOLD) {
             // Approved! Post the file-capped plan
@@ -337,7 +353,8 @@ export async function planTask(task, config) {
                 console.log(`${ts()} ${taskLabel}   ${chalk.dim(risksMsg)}`);
                 await postLog(task.id, risksMsg);
             }
-            return await postValidatedPlan(task.id, plan, config.agentId, taskLabel, elapsed);
+            const planningDurationMs = Date.now() - startTime;
+            return await postValidatedPlan(task.id, plan, config.agentId, taskLabel, elapsed, criticResult.score, criticResult.risks, criticHistory, totalFileCapTruncations, planningDurationMs, iteration);
         }
         // 2f. Rejected — append critic feedback for next iteration
         if (iteration < MAX_ITERATIONS) {
@@ -382,13 +399,19 @@ export async function planTask(task, config) {
  * Re-serializes the plan as a JSON code block since the server-side
  * parseExecutionPlan() expects that format.
  */
-async function postValidatedPlan(taskId, plan, agentId, taskLabel, elapsed) {
+async function postValidatedPlan(taskId, plan, agentId, taskLabel, elapsed, criticScore, criticRisks, criticHistory, fileCapTruncations, planningDurationMs, criticIterations) {
     const serialized = serializePlan(plan);
     try {
         const result = await api.post("/api/agent/plan-result", {
             taskId,
             rawOutput: serialized,
             agentId,
+            criticScore,
+            criticRisks,
+            criticHistory,
+            criticIterations,
+            fileCapTruncations,
+            planningDurationMs,
         });
         const storyCount = result.data.storyCount;
         console.log(`${ts()} ${taskLabel} ${chalk.green("✓")} Plan validated: ${chalk.bold(storyCount)} stories → ${chalk.green("queued")}`);

package/dist/poller.js

@@ -8,10 +8,15 @@ import chalk from "chalk";
 import { api } from "./api.js";
 import { planTask } from "./planner.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 },
@@ -174,6 +182,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 +191,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/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.1",
+  "version": "0.3.0",
   "description": "WorkerMill Remote Agent - Run AI workers locally with your Claude Max subscription",
   "type": "module",
   "main": "./dist/index.js",