@epic-cloudcontrol/daemon 0.2.0

package/dist/task-executor.js

@@ -0,0 +1,195 @@
+import { ModelRouter } from "./model-router.js";
+import { fetchWithRetry } from "./retry.js";
+import { cleanupTaskTmpDir } from "./sandbox.js";
+const retryOpts = {
+    maxRetries: 3,
+    baseDelayMs: 1000,
+    onRetry: (attempt, err) => {
+        console.log(`[executor] Retry attempt ${attempt}: ${err.message}`);
+    },
+};
+export class TaskExecutor {
+    config;
+    workerId = null;
+    router;
+    secrets = new Map();
+    constructor(config) {
+        this.config = config;
+        this.router = new ModelRouter();
+    }
+    setWorkerId(id) {
+        this.workerId = id;
+    }
+    getAvailableModels() {
+        return this.router.listModels();
+    }
+    get headers() {
+        return {
+            authorization: `Bearer ${this.config.apiKey}`,
+            "content-type": "application/json",
+        };
+    }
+    async claimTask(taskId) {
+        if (!this.workerId)
+            throw new Error("Worker not registered");
+        try {
+            const res = await fetchWithRetry(`${this.config.apiUrl}/api/tasks/${taskId}/claim`, {
+                method: "POST",
+                headers: this.headers,
+                body: JSON.stringify({ workerId: this.workerId }),
+            }, retryOpts);
+            const { task } = await res.json();
+            return task;
+        }
+        catch (err) {
+            console.log(`[executor] Failed to claim task ${taskId}: ${err.message}`);
+            return null;
+        }
+    }
+    async executeTask(task) {
+        console.log(`[executor] Executing: ${task.title}`);
+        // Update status to running
+        await this.updateTaskStatus(task.id, "running");
+        // Resolve process for this task type (if any)
+        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}"`);
+            }
+        }
+        // Fetch any needed secrets
+        if (task.credentialsNeeded && task.credentialsNeeded.length > 0) {
+            for (const key of task.credentialsNeeded) {
+                const value = await this.fetchSecret(key, task.id);
+                if (value) {
+                    this.secrets.set(key, value);
+                    console.log(`[executor] 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"})`);
+        // Pass taskId to adapter for sandbox isolation
+        if ("setTaskId" in adapter && typeof adapter.setTaskId === "function") {
+            adapter.setTaskId(task.id);
+        }
+        // Execute with selected model adapter
+        let result;
+        try {
+            result = await 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}`);
+            await this.submitResult(task.id, {
+                status: "human_required",
+                result: result.result,
+                dialogue: result.dialogue,
+                humanContext: result.humanRequired.reason,
+                metadata: result.metadata,
+            });
+        }
+        else if (result.success) {
+            console.log(`[executor] Task completed successfully`);
+            await this.submitResult(task.id, {
+                status: "completed",
+                result: result.result,
+                dialogue: result.dialogue,
+                metadata: result.metadata,
+            });
+        }
+        else {
+            console.log(`[executor] Task failed`);
+            await this.submitResult(task.id, {
+                status: "failed",
+                result: result.result,
+                dialogue: result.dialogue,
+                metadata: result.metadata,
+            });
+        }
+    }
+    async submitResult(taskId, result) {
+        if (!this.workerId)
+            throw new Error("Worker not registered");
+        await fetchWithRetry(`${this.config.apiUrl}/api/tasks/${taskId}/submit`, {
+            method: "POST",
+            headers: this.headers,
+            body: JSON.stringify({ workerId: this.workerId, ...result }),
+        }, retryOpts);
+        console.log(`[executor] Task ${taskId} submitted as ${result.status}`);
+    }
+    async updateTaskStatus(taskId, status) {
+        try {
+            await fetchWithRetry(`${this.config.apiUrl}/api/tasks/${taskId}`, {
+                method: "PATCH",
+                headers: this.headers,
+                body: JSON.stringify({ status }),
+            }, { maxRetries: 2, baseDelayMs: 500 });
+        }
+        catch {
+            // Status update failure is non-fatal — task will still be processed
+            console.log(`[executor] Warning: failed to update status to ${status}`);
+        }
+    }
+    async resolveProcess(taskType) {
+        try {
+            const res = await fetchWithRetry(`${this.config.apiUrl}/api/processes/resolve?taskType=${encodeURIComponent(taskType)}`, { headers: this.headers }, { maxRetries: 2, baseDelayMs: 1000 });
+            const { parsed } = await res.json();
+            if (!parsed?.steps?.length)
+                return null;
+            // Format steps as instructions for the AI
+            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];
+                let desc = `Step ${i + 1} [${step.type}]: ${step.id}`;
+                if (step.prompt)
+                    desc += ` — ${step.prompt}`;
+                if (step.action)
+                    desc += ` — action: ${step.action}`;
+                if (step.target)
+                    desc += ` (target: ${step.target})`;
+                if (step.gate === "approval_required")
+                    desc += ` [REQUIRES HUMAN APPROVAL]`;
+                lines.push(desc);
+            }
+            if (parsed.credentialsNeeded?.length > 0) {
+                lines.push(`\nCredentials available: ${parsed.credentialsNeeded.join(", ")}`);
+            }
+            return lines.join("\n");
+        }
+        catch {
+            // Process resolution failure is non-fatal
+            return null;
+        }
+    }
+    async fetchSecret(key, taskId) {
+        try {
+            const res = await fetchWithRetry(`${this.config.apiUrl}/api/secrets/${encodeURIComponent(key)}?task_id=${taskId}`, { headers: this.headers }, retryOpts);
+            const { value } = await res.json();
+            return value;
+        }
+        catch (err) {
+            console.log(`[executor] Failed to fetch secret "${key}": ${err.message}`);
+            return null;
+        }
+    }
+    async pollTasks() {
+        try {
+            const res = await fetchWithRetry(`${this.config.apiUrl}/api/tasks?status=pending&limit=10&workerId=${this.workerId}`, { headers: this.headers }, { maxRetries: 2, baseDelayMs: 2000 });
+            const { tasks } = await res.json();
+            return tasks;
+        }
+        catch {
+            return [];
+        }
+    }
+}
+//# sourceMappingURL=task-executor.js.map

package/dist/version.d.ts

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

package/dist/version.js

@@ -0,0 +1,17 @@
+import { readFileSync } from "fs";
+import { dirname, join } from "path";
+import { fileURLToPath } from "url";
+const __dirname = dirname(fileURLToPath(import.meta.url));
+function readVersion() {
+    // Works from both src/ (dev with tsx) and dist/ (compiled)
+    for (const rel of ["../package.json", "../../package.json"]) {
+        try {
+            const raw = readFileSync(join(__dirname, rel), "utf-8");
+            return JSON.parse(raw).version;
+        }
+        catch { /* try next */ }
+    }
+    return "0.0.0";
+}
+export const DAEMON_VERSION = readVersion();
+//# sourceMappingURL=version.js.map

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "@epic-cloudcontrol/daemon",
+  "version": "0.2.0",
+  "description": "CloudControl local daemon — executes AI agent tasks on worker machines",
+  "type": "module",
+  "main": "dist/cli.js",
+  "bin": {
+    "cloudcontrol": "dist/cli.js"
+  },
+  "files": [
+    "dist/**/*.js",
+    "dist/**/*.d.ts"
+  ],
+  "scripts": {
+    "dev": "tsx src/cli.ts",
+    "build": "tsc",
+    "prepublishOnly": "npm run build",
+    "start": "node dist/cli.js start"
+  },
+  "engines": {
+    "node": ">=20.0.0"
+  },
+  "dependencies": {
+    "@anthropic-ai/sdk": "^0.82.0",
+    "@modelcontextprotocol/sdk": "^1.29.0",
+    "commander": "^13.0.0",
+    "dotenv": "^17.4.0",
+    "yaml": "^2.8.3",
+    "zod": "^4.3.6"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "tsx": "^4.19.0",
+    "typescript": "^5.7.0"
+  }
+}