@epic-cloudcontrol/daemon 0.2.1 → 0.3.0

package/dist/models/gemini-api.js

@@ -0,0 +1,134 @@
+/**
+ * Google Gemini API Adapter
+ *
+ * Calls the Google Generative AI API directly (no SDK dependency).
+ * Supports Gemini 2.5 Pro, Flash, and any model on the API.
+ *
+ * Requires: GOOGLE_API_KEY environment variable.
+ */
+import { buildSandboxPrompt, getDefaultSandboxConfig } from "../sandbox.js";
+const GEMINI_API_URL = "https://generativelanguage.googleapis.com/v1beta/models";
+export class GeminiAPIAdapter {
+    model;
+    apiKey;
+    sandboxConfig;
+    constructor(model = "gemini-2.5-pro", apiKey, sandboxConfig) {
+        this.model = model;
+        this.apiKey = apiKey || process.env.GOOGLE_API_KEY || "";
+        this.sandboxConfig = sandboxConfig || getDefaultSandboxConfig();
+    }
+    async execute(task) {
+        const dialogue = [];
+        const startTime = Date.now();
+        let totalTokens = 0;
+        const sandboxRules = buildSandboxPrompt(this.sandboxConfig);
+        const systemPrompt = `You are a CloudControl task executor. You complete tasks efficiently and report results clearly.
+
+When you encounter something you cannot complete (CAPTCHA, phone verification, account creation, ambiguous decision), respond with:
+[HUMAN_REQUIRED]: <reason>
+
+Always end your final response with:
+[RESULT]: <brief summary of what was accomplished>
+${sandboxRules}`;
+        let userMessage = `## Task: ${task.title}\n`;
+        if (task.description)
+            userMessage += `\n${task.description}\n`;
+        if (task.taskType)
+            userMessage += `\nTask type: ${task.taskType}\n`;
+        if (task.processHint)
+            userMessage += `\nProcess hint: ${task.processHint}\n`;
+        if (task.context) {
+            userMessage += `\nContext:\n\`\`\`json\n${JSON.stringify(task.context, null, 2)}\n\`\`\`\n`;
+        }
+        if (task.humanContext) {
+            userMessage += `\nHuman feedback from previous attempt:\n${task.humanContext}\n`;
+        }
+        dialogue.push({
+            role: "user",
+            content: userMessage,
+            timestamp: new Date().toISOString(),
+        });
+        try {
+            const url = `${GEMINI_API_URL}/${this.model}:generateContent?key=${this.apiKey}`;
+            const response = await fetch(url, {
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify({
+                    systemInstruction: { parts: [{ text: systemPrompt }] },
+                    contents: [{ role: "user", parts: [{ text: userMessage }] }],
+                    generationConfig: {
+                        maxOutputTokens: 4096,
+                    },
+                }),
+            });
+            if (!response.ok) {
+                const err = await response.text();
+                throw new Error(`Gemini API ${response.status}: ${err}`);
+            }
+            const data = await response.json();
+            const assistantContent = data.candidates?.[0]?.content?.parts
+                ?.map((p) => p.text)
+                .join("\n") || "";
+            totalTokens = data.usageMetadata?.totalTokenCount || 0;
+            dialogue.push({
+                role: "assistant",
+                content: assistantContent,
+                timestamp: new Date().toISOString(),
+            });
+            // Check for human required
+            const humanMatch = assistantContent.match(/\[HUMAN_REQUIRED\]:\s*(.*)/s);
+            if (humanMatch) {
+                return {
+                    success: false,
+                    dialogue,
+                    result: { raw_response: assistantContent },
+                    metadata: {
+                        model: this.model,
+                        tokens_used: totalTokens,
+                        duration_ms: Date.now() - startTime,
+                    },
+                    humanRequired: {
+                        reason: humanMatch[1].trim(),
+                        context: assistantContent,
+                    },
+                };
+            }
+            const resultMatch = assistantContent.match(/\[RESULT\]:\s*(.*)/s);
+            const resultSummary = resultMatch
+                ? resultMatch[1].trim()
+                : assistantContent.slice(0, 500);
+            return {
+                success: true,
+                dialogue,
+                result: {
+                    summary: resultSummary,
+                    raw_response: assistantContent,
+                },
+                metadata: {
+                    model: this.model,
+                    tokens_used: totalTokens,
+                    duration_ms: Date.now() - startTime,
+                },
+            };
+        }
+        catch (error) {
+            const errMsg = error instanceof Error ? error.message : "Unknown error";
+            dialogue.push({
+                role: "system",
+                content: `Execution error: ${errMsg}`,
+                timestamp: new Date().toISOString(),
+            });
+            return {
+                success: false,
+                dialogue,
+                result: { error: errMsg },
+                metadata: {
+                    model: this.model,
+                    tokens_used: totalTokens,
+                    duration_ms: Date.now() - startTime,
+                },
+            };
+        }
+    }
+}
+//# sourceMappingURL=gemini-api.js.map

package/dist/models/openai.d.ts

@@ -0,0 +1,24 @@
+/**
+ * OpenAI GPT Adapter
+ *
+ * Calls the OpenAI Chat Completions API directly (no SDK dependency).
+ * Supports GPT-4o, GPT-4o-mini, and any model available on the API.
+ *
+ * Requires: OPENAI_API_KEY environment variable.
+ */
+import { type SandboxConfig } from "../sandbox.js";
+import type { ExecutionResult } from "./claude.js";
+export declare class OpenAIAdapter {
+    private model;
+    private apiKey;
+    private sandboxConfig;
+    constructor(model?: string, apiKey?: string, sandboxConfig?: SandboxConfig);
+    execute(task: {
+        title: string;
+        description?: string | null;
+        taskType?: string | null;
+        context?: Record<string, unknown> | null;
+        processHint?: string | null;
+        humanContext?: string | null;
+    }): Promise<ExecutionResult>;
+}

package/dist/models/openai.js

@@ -0,0 +1,135 @@
+/**
+ * OpenAI GPT Adapter
+ *
+ * Calls the OpenAI Chat Completions API directly (no SDK dependency).
+ * Supports GPT-4o, GPT-4o-mini, and any model available on the API.
+ *
+ * Requires: OPENAI_API_KEY environment variable.
+ */
+import { buildSandboxPrompt, getDefaultSandboxConfig } from "../sandbox.js";
+const OPENAI_API_URL = "https://api.openai.com/v1/chat/completions";
+export class OpenAIAdapter {
+    model;
+    apiKey;
+    sandboxConfig;
+    constructor(model = "gpt-4o", apiKey, sandboxConfig) {
+        this.model = model;
+        this.apiKey = apiKey || process.env.OPENAI_API_KEY || "";
+        this.sandboxConfig = sandboxConfig || getDefaultSandboxConfig();
+    }
+    async execute(task) {
+        const dialogue = [];
+        const startTime = Date.now();
+        let totalTokens = 0;
+        const sandboxRules = buildSandboxPrompt(this.sandboxConfig);
+        const systemPrompt = `You are a CloudControl task executor. You complete tasks efficiently and report results clearly.
+
+When you encounter something you cannot complete (CAPTCHA, phone verification, account creation, ambiguous decision), respond with:
+[HUMAN_REQUIRED]: <reason>
+
+Always end your final response with:
+[RESULT]: <brief summary of what was accomplished>
+${sandboxRules}`;
+        let userMessage = `## Task: ${task.title}\n`;
+        if (task.description)
+            userMessage += `\n${task.description}\n`;
+        if (task.taskType)
+            userMessage += `\nTask type: ${task.taskType}\n`;
+        if (task.processHint)
+            userMessage += `\nProcess hint: ${task.processHint}\n`;
+        if (task.context) {
+            userMessage += `\nContext:\n\`\`\`json\n${JSON.stringify(task.context, null, 2)}\n\`\`\`\n`;
+        }
+        if (task.humanContext) {
+            userMessage += `\nHuman feedback from previous attempt:\n${task.humanContext}\n`;
+        }
+        dialogue.push({
+            role: "user",
+            content: userMessage,
+            timestamp: new Date().toISOString(),
+        });
+        try {
+            const response = await fetch(OPENAI_API_URL, {
+                method: "POST",
+                headers: {
+                    "Authorization": `Bearer ${this.apiKey}`,
+                    "Content-Type": "application/json",
+                },
+                body: JSON.stringify({
+                    model: this.model,
+                    max_tokens: 4096,
+                    messages: [
+                        { role: "system", content: systemPrompt },
+                        { role: "user", content: userMessage },
+                    ],
+                }),
+            });
+            if (!response.ok) {
+                const err = await response.text();
+                throw new Error(`OpenAI API ${response.status}: ${err}`);
+            }
+            const data = await response.json();
+            const assistantContent = data.choices[0]?.message?.content || "";
+            totalTokens = data.usage?.total_tokens || 0;
+            dialogue.push({
+                role: "assistant",
+                content: assistantContent,
+                timestamp: new Date().toISOString(),
+            });
+            // Check for human required
+            const humanMatch = assistantContent.match(/\[HUMAN_REQUIRED\]:\s*(.*)/s);
+            if (humanMatch) {
+                return {
+                    success: false,
+                    dialogue,
+                    result: { raw_response: assistantContent },
+                    metadata: {
+                        model: this.model,
+                        tokens_used: totalTokens,
+                        duration_ms: Date.now() - startTime,
+                    },
+                    humanRequired: {
+                        reason: humanMatch[1].trim(),
+                        context: assistantContent,
+                    },
+                };
+            }
+            const resultMatch = assistantContent.match(/\[RESULT\]:\s*(.*)/s);
+            const resultSummary = resultMatch
+                ? resultMatch[1].trim()
+                : assistantContent.slice(0, 500);
+            return {
+                success: true,
+                dialogue,
+                result: {
+                    summary: resultSummary,
+                    raw_response: assistantContent,
+                },
+                metadata: {
+                    model: this.model,
+                    tokens_used: totalTokens,
+                    duration_ms: Date.now() - startTime,
+                },
+            };
+        }
+        catch (error) {
+            const errMsg = error instanceof Error ? error.message : "Unknown error";
+            dialogue.push({
+                role: "system",
+                content: `Execution error: ${errMsg}`,
+                timestamp: new Date().toISOString(),
+            });
+            return {
+                success: false,
+                dialogue,
+                result: { error: errMsg },
+                metadata: {
+                    model: this.model,
+                    tokens_used: totalTokens,
+                    duration_ms: Date.now() - startTime,
+                },
+            };
+        }
+    }
+}
+//# sourceMappingURL=openai.js.map

package/dist/multi-profile.js

@@ -4,6 +4,8 @@ import { listProfiles } from "./profile.js";
 import { TaskExecutor } from "./task-executor.js";
 import { fetchWithRetry } from "./retry.js";
 import { DAEMON_VERSION } from "./version.js";
+import { createLogger } from "./logger.js";
+const log = createLogger("daemon");
 export async function startAllProfiles(overrides) {
     const profiles = listProfiles();
     if (profiles.length === 0) {
@@ -26,7 +28,7 @@ export async function startAllProfiles(overrides) {
             model: overrides.model,
         });
         if (!config.apiKey) {
-            console.log(`  [${name}] Skipping — no API key`);
+            log.info(`[${name}] Skipping — no API key`);
             continue;
         }
         const executor = new TaskExecutor(config);
@@ -67,10 +69,10 @@ export async function startAllProfiles(overrides) {
             const data = await res.json();
             pw.workerId = data.worker.id;
             executor.setWorkerId(data.worker.id);
-            console.log(`  [${pw.teamName}] Registered as ${pw.workerId.slice(0, 8)}...`);
+            log.info(`[${pw.teamName}] Registered as ${pw.workerId.slice(0, 8)}...`);
         }
         catch (err) {
-            console.error(`  [${pw.teamName}] Registration failed: ${err.message}`);
+            log.error(`[${pw.teamName}] Registration failed: ${err.message}`);
             continue;
         }
         // Set up polling
@@ -85,12 +87,12 @@ export async function startAllProfiles(overrides) {
                         sendHeartbeat(pw, "busy");
                         const task = await executor.claimTask(tasks[0].id);
                         if (task) {
-                            console.log(`  [${pw.teamName}] Claimed: ${task.title}`);
+                            log.info(`[${pw.teamName}] Claimed: ${task.title}`);
                             await executor.executeTask(task);
                         }
                     }
                     catch (err) {
-                        console.error(`  [${pw.teamName}] Execution error: ${err.message}`);
+                        log.error(`[${pw.teamName}] Execution error: ${err.message}`);
                     }
                     finally {
                         pw.executing = false;
@@ -106,10 +108,10 @@ export async function startAllProfiles(overrides) {
         workers.push(pw);
     }
     if (workers.length === 0) {
-        console.error("\nNo workers started. Check your profiles.");
+        log.error("No workers started. Check your profiles.");
         process.exit(1);
     }
-    console.log(`\nRunning ${workers.length} worker(s). Press Ctrl+C to stop.\n`);
+    log.info(`Running ${workers.length} worker(s). Press Ctrl+C to stop.`);
     return () => {
         for (const pw of workers) {
             if (pw.pollTimer)

package/dist/step-runner.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Process YAML step runner.
+ * Executes process steps in sequence, pausing at human gates.
+ */
+import type { ModelAdapter, TaskInput } from "./model-router.js";
+import type { ExecutionResult } from "./models/claude.js";
+export interface ProcessStep {
+    id: string;
+    type: "browser" | "ai" | "human" | "api" | "shell";
+    action?: string;
+    prompt?: string;
+    target?: string;
+    selector?: string;
+    gate?: "none" | "approval_required";
+    description?: string;
+}
+export interface StepRunResult {
+    completed: boolean;
+    stepIndex: number;
+    results: Array<{
+        stepId: string;
+        status: string;
+        output?: string;
+    }>;
+    humanRequired?: {
+        reason: string;
+        stepId: string;
+    };
+    finalResult?: ExecutionResult;
+}
+export declare function runProcessSteps(steps: ProcessStep[], task: TaskInput, adapter: {
+    adapter: ModelAdapter;
+    name: string;
+}, submitActivity: (content: string) => Promise<void>): Promise<StepRunResult>;

package/dist/step-runner.js

@@ -0,0 +1,94 @@
+/**
+ * Process YAML step runner.
+ * Executes process steps in sequence, pausing at human gates.
+ */
+import { createLogger } from "./logger.js";
+const log = createLogger("steps");
+export async function runProcessSteps(steps, task, adapter, submitActivity) {
+    const results = [];
+    for (let i = 0; i < steps.length; i++) {
+        const step = steps[i];
+        log.info(`Step ${i + 1}/${steps.length}: [${step.type}] ${step.id}`);
+        await submitActivity(`Step ${i + 1}/${steps.length}: [${step.type}] ${step.id}`);
+        switch (step.type) {
+            case "ai": {
+                const prompt = step.prompt
+                    ? `${step.prompt}\n\nTask context: ${task.title}\n${task.description || ""}`
+                    : `${task.title}\n${task.description || ""}`;
+                const result = await adapter.adapter.execute({
+                    ...task,
+                    description: prompt,
+                    processHint: `You are on step ${i + 1} of ${steps.length}: "${step.id}". ${step.description || ""}`,
+                });
+                results.push({
+                    stepId: step.id,
+                    status: result.success ? "completed" : "failed",
+                    output: result.result?.summary || JSON.stringify(result.result),
+                });
+                if (result.humanRequired) {
+                    return {
+                        completed: false,
+                        stepIndex: i,
+                        results,
+                        humanRequired: { reason: result.humanRequired.reason, stepId: step.id },
+                        finalResult: result,
+                    };
+                }
+                if (!result.success) {
+                    return { completed: false, stepIndex: i, results, finalResult: result };
+                }
+                break;
+            }
+            case "human": {
+                if (step.gate === "approval_required") {
+                    log.info(`Human gate at step ${step.id} — pausing for approval`);
+                    return {
+                        completed: false,
+                        stepIndex: i,
+                        results,
+                        humanRequired: {
+                            reason: step.prompt || step.description || `Step "${step.id}" requires human approval`,
+                            stepId: step.id,
+                        },
+                    };
+                }
+                results.push({ stepId: step.id, status: "skipped", output: "No gate required" });
+                break;
+            }
+            case "browser": {
+                try {
+                    const { executeBrowserStep } = await import("./browser.js");
+                    const output = await executeBrowserStep(step);
+                    results.push({ stepId: step.id, status: "completed", output });
+                }
+                catch {
+                    log.warn(`Browser step "${step.id}" skipped — Playwright not installed`);
+                    results.push({ stepId: step.id, status: "skipped", output: "Playwright not installed" });
+                }
+                break;
+            }
+            case "api":
+            case "shell": {
+                log.warn(`Step type "${step.type}" not yet implemented — skipping "${step.id}"`);
+                results.push({ stepId: step.id, status: "skipped", output: `${step.type} steps not yet implemented` });
+                break;
+            }
+        }
+    }
+    const lastAiResult = results.filter((r) => r.status === "completed").pop();
+    return {
+        completed: true,
+        stepIndex: steps.length,
+        results,
+        finalResult: {
+            success: true,
+            dialogue: [],
+            result: {
+                summary: lastAiResult?.output || "All process steps completed",
+                steps: results,
+            },
+            metadata: { model: adapter.name, tokens_used: 0, duration_ms: 0 },
+        },
+    };
+}
+//# sourceMappingURL=step-runner.js.map

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;
         }
     }