@epic-cloudcontrol/daemon 0.2.0 → 0.3.0

package/dist/task-executor.js

@@ -1,11 +1,14 @@
 import { ModelRouter } from "./model-router.js";
 import { fetchWithRetry } from "./retry.js";
 import { cleanupTaskTmpDir } from "./sandbox.js";
+import { createLogger } from "./logger.js";
+import { runProcessSteps } from "./step-runner.js";
+const log = createLogger("executor");
 const retryOpts = {
     maxRetries: 3,
     baseDelayMs: 1000,
     onRetry: (attempt, err) => {
-        console.log(`[executor] Retry attempt ${attempt}: ${err.message}`);
+        log.info(`Retry attempt ${attempt}: ${err.message}`);
     },
 };
 export class TaskExecutor {
@@ -42,21 +45,21 @@ export class TaskExecutor {
             return task;
         }
         catch (err) {
-            console.log(`[executor] Failed to claim task ${taskId}: ${err.message}`);
+            log.warn(`Failed to claim task ${taskId}: ${err.message}`);
             return null;
         }
     }
     async executeTask(task) {
-        console.log(`[executor] Executing: ${task.title}`);
-        // Update status to running
+        log.info(`Executing: ${task.title}`);
         await this.updateTaskStatus(task.id, "running");
         // Resolve process for this task type (if any)
+        let processSteps = null;
         if (task.taskType) {
-            const processSteps = await this.resolveProcess(task.taskType);
-            if (processSteps) {
-                // Inject process steps into the task's processHint
-                task.processHint = processSteps;
-                console.log(`[executor] Process loaded for type "${task.taskType}"`);
+            const processData = await this.resolveProcess(task.taskType);
+            if (processData) {
+                processSteps = processData.steps;
+                task.processHint = processData.hint;
+                log.info(`Process loaded for type "${task.taskType}" (${processData.steps.length} steps)`);
             }
         }
         // Fetch any needed secrets
@@ -65,30 +68,65 @@ export class TaskExecutor {
                 const value = await this.fetchSecret(key, task.id);
                 if (value) {
                     this.secrets.set(key, value);
-                    console.log(`[executor] Secret "${key}" loaded`);
+                    log.info(`Secret "${key}" loaded`);
                 }
             }
         }
         // Select model based on task's hint
-        const { adapter, name: modelName } = this.router.select(task.modelHint);
-        console.log(`[executor] Model: ${modelName} (hint: ${task.modelHint || "auto"})`);
+        const model = this.router.select(task.modelHint);
+        log.info(`Model: ${model.name} (hint: ${task.modelHint || "auto"})`);
         // Pass taskId to adapter for sandbox isolation
-        if ("setTaskId" in adapter && typeof adapter.setTaskId === "function") {
-            adapter.setTaskId(task.id);
+        if ("setTaskId" in model.adapter && typeof model.adapter.setTaskId === "function") {
+            model.adapter.setTaskId(task.id);
         }
-        // Execute with selected model adapter
         let result;
         try {
-            result = await adapter.execute(task);
+            if (processSteps && processSteps.length > 0) {
+                // Step-by-step process execution
+                log.info(`Running ${processSteps.length} process steps`);
+                const stepResult = await runProcessSteps(processSteps, task, model, async (content) => {
+                    try {
+                        await fetchWithRetry(`${this.config.apiUrl}/api/tasks/${task.id}/activity`, {
+                            method: "POST",
+                            headers: this.headers,
+                            body: JSON.stringify({ activityType: "progress", content, workerId: this.workerId }),
+                        }, { maxRetries: 1, baseDelayMs: 500 });
+                    }
+                    catch { /* non-fatal */ }
+                });
+                if (stepResult.humanRequired) {
+                    result = stepResult.finalResult || {
+                        success: false,
+                        dialogue: [],
+                        result: { steps: stepResult.results },
+                        metadata: { model: model.name, tokens_used: 0, duration_ms: 0 },
+                        humanRequired: { reason: stepResult.humanRequired.reason, context: `Paused at step: ${stepResult.humanRequired.stepId}` },
+                    };
+                }
+                else if (stepResult.finalResult) {
+                    result = stepResult.finalResult;
+                }
+                else {
+                    result = {
+                        success: stepResult.completed,
+                        dialogue: [],
+                        result: { steps: stepResult.results },
+                        metadata: { model: model.name, tokens_used: 0, duration_ms: 0 },
+                    };
+                }
+            }
+            else {
+                // No process steps — single AI call (existing behavior)
+                result = await model.adapter.execute(task);
+            }
         }
         finally {
-            // Flush secrets and cleanup sandbox tmpdir
             this.secrets.clear();
             cleanupTaskTmpDir(task.id);
         }
         // Submit result
         if (result.humanRequired) {
-            console.log(`[executor] Task requires human input: ${result.humanRequired.reason}`);
+            log.info(`Task requires human input: ${result.humanRequired.reason}`);
             await this.submitResult(task.id, {
                 status: "human_required",
                 result: result.result,
@@ -98,7 +136,7 @@ export class TaskExecutor {
             });
         }
         else if (result.success) {
-            console.log(`[executor] Task completed successfully`);
+            log.info("Task completed successfully");
             await this.submitResult(task.id, {
                 status: "completed",
                 result: result.result,
@@ -107,7 +145,7 @@ export class TaskExecutor {
             });
         }
         else {
-            console.log(`[executor] Task failed`);
+            log.info("Task failed");
             await this.submitResult(task.id, {
                 status: "failed",
                 result: result.result,
@@ -124,7 +162,7 @@ export class TaskExecutor {
             headers: this.headers,
             body: JSON.stringify({ workerId: this.workerId, ...result }),
         }, retryOpts);
-        console.log(`[executor] Task ${taskId} submitted as ${result.status}`);
+        log.info(`Task ${taskId} submitted as ${result.status}`);
     }
     async updateTaskStatus(taskId, status) {
         try {
@@ -136,7 +174,7 @@ export class TaskExecutor {
         }
         catch {
             // Status update failure is non-fatal — task will still be processed
-            console.log(`[executor] Warning: failed to update status to ${status}`);
+            log.warn(`Failed to update status to ${status}`);
         }
     }
     async resolveProcess(taskType) {
@@ -145,7 +183,7 @@ export class TaskExecutor {
             const { parsed } = await res.json();
             if (!parsed?.steps?.length)
                 return null;
-            // Format steps as instructions for the AI
+            // Build text hint for AI context
             const lines = [`Follow this process (${parsed.name} v${parsed.version}):\n`];
             for (let i = 0; i < parsed.steps.length; i++) {
                 const step = parsed.steps[i];
@@ -160,13 +198,12 @@ export class TaskExecutor {
                     desc += ` [REQUIRES HUMAN APPROVAL]`;
                 lines.push(desc);
             }
-            if (parsed.credentialsNeeded?.length > 0) {
+            if (parsed.credentialsNeeded?.length) {
                 lines.push(`\nCredentials available: ${parsed.credentialsNeeded.join(", ")}`);
             }
-            return lines.join("\n");
+            return { steps: parsed.steps, hint: lines.join("\n") };
         }
         catch {
-            // Process resolution failure is non-fatal
             return null;
         }
     }
@@ -177,7 +214,7 @@ export class TaskExecutor {
             return value;
         }
         catch (err) {
-            console.log(`[executor] Failed to fetch secret "${key}": ${err.message}`);
+            log.warn(`Failed to fetch secret "${key}": ${err.message}`);
             return null;
         }
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@epic-cloudcontrol/daemon",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "CloudControl local daemon — executes AI agent tasks on worker machines",
   "type": "module",
   "main": "dist/cli.js",
@@ -14,6 +14,8 @@
   "scripts": {
     "dev": "tsx src/cli.ts",
     "build": "tsc",
+    "test": "vitest run",
+    "test:watch": "vitest",
     "prepublishOnly": "npm run build",
     "start": "node dist/cli.js start"
   },
@@ -31,6 +33,15 @@
   "devDependencies": {
     "@types/node": "^22.0.0",
     "tsx": "^4.19.0",
-    "typescript": "^5.7.0"
+    "typescript": "^5.7.0",
+    "vitest": "^4.1.2"
+  },
+  "peerDependencies": {
+    "playwright": ">=1.40.0"
+  },
+  "peerDependenciesMeta": {
+    "playwright": {
+      "optional": true
+    }
   }
 }