@epic-cloudcontrol/daemon 0.2.0 → 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/sandbox.js

@@ -7,6 +7,9 @@
  * - Environment variable filtering
  * - Output size limits
  */
+import os from "os";
+import fs from "fs";
+import path from "path";
 const DEFAULT_BLOCKED_COMMANDS = [
     "rm -rf /",
     "rm -rf ~",
@@ -144,9 +147,6 @@ export function truncateOutput(output, maxBytes) {
  * Returns the path. Caller is responsible for cleanup.
  */
 export function createTaskTmpDir(taskId) {
-    const os = require("os");
-    const fs = require("fs");
-    const path = require("path");
     const dir = path.join(os.tmpdir(), `cloudcontrol-${taskId.slice(0, 8)}`);
     if (!fs.existsSync(dir)) {
         fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
@@ -157,9 +157,6 @@ export function createTaskTmpDir(taskId) {
  * Clean up a task's temp directory.
  */
 export function cleanupTaskTmpDir(taskId) {
-    const os = require("os");
-    const fs = require("fs");
-    const path = require("path");
     const dir = path.join(os.tmpdir(), `cloudcontrol-${taskId.slice(0, 8)}`);
     try {
         fs.rmSync(dir, { recursive: true, force: true });

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