@epic-cloudcontrol/daemon 0.2.0

package/dist/model-router.js

@@ -0,0 +1,146 @@
+import { ClaudeAdapter } from "./models/claude.js";
+import { OllamaAdapter } from "./models/ollama.js";
+import { CliAdapter, KNOWN_CLIS, parseCliModels } from "./models/cli-adapter.js";
+import { execSync } from "child_process";
+function isCommandInstalled(command) {
+    try {
+        execSync(`which ${command}`, { stdio: "ignore" });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * ModelRouter manages a roster of available AI models and selects
+ * the best one for each task based on the task's modelHint.
+ *
+ * Models are detected from:
+ * 1. ANTHROPIC_API_KEY → Claude API (sonnet + haiku)
+ * 2. Installed CLIs → auto-detected from KNOWN_CLIS + CLOUDCONTROL_CLI_MODELS env
+ * 3. CLOUDCONTROL_OLLAMA_MODELS → Ollama local models
+ */
+export class ModelRouter {
+    models = [];
+    defaultModel;
+    constructor() {
+        this.defaultModel = "";
+        this.detectAvailableModels();
+    }
+    detectAvailableModels() {
+        // 1. Claude API models (require ANTHROPIC_API_KEY)
+        const apiKey = process.env.ANTHROPIC_API_KEY;
+        const hasApiKey = apiKey && apiKey !== "your-anthropic-api-key-here" && apiKey.length > 0;
+        if (hasApiKey) {
+            this.models.push({
+                name: "claude-sonnet",
+                adapter: new ClaudeAdapter("claude-sonnet-4-20250514"),
+                traits: ["smartest", "code", "vision"],
+                available: true,
+            });
+            this.models.push({
+                name: "claude-haiku",
+                adapter: new ClaudeAdapter("claude-haiku-4-5-20251001"),
+                traits: ["cheapest", "fastest"],
+                available: true,
+            });
+        }
+        // 2. Auto-detect installed CLIs from KNOWN_CLIS
+        const cliTraits = {
+            "claude-code": ["smartest", "code", "local"],
+            gemini: ["smartest", "code", "local"],
+            codex: ["code", "local"],
+            aider: ["code", "local"],
+            goose: ["code", "local"],
+        };
+        for (const [name, config] of Object.entries(KNOWN_CLIS)) {
+            if (isCommandInstalled(config.command)) {
+                this.models.push({
+                    name,
+                    adapter: new CliAdapter({ name, ...config }),
+                    traits: cliTraits[name] || ["code", "local"],
+                    available: true,
+                });
+            }
+        }
+        // 3. Custom CLI models from env var
+        //    Format: "name:command:args;name2:command2:args"
+        //    Or just names from KNOWN_CLIS: "gemini;aider"
+        const customClis = process.env.CLOUDCONTROL_CLI_MODELS;
+        if (customClis) {
+            const configs = parseCliModels(customClis);
+            for (const config of configs) {
+                // Skip if already registered (auto-detected above)
+                if (this.models.some((m) => m.name === config.name))
+                    continue;
+                this.models.push({
+                    name: config.name,
+                    adapter: new CliAdapter(config),
+                    traits: ["code", "local"],
+                    available: true,
+                });
+            }
+        }
+        // 4. Ollama models
+        const ollamaUrl = process.env.OLLAMA_URL || "http://localhost:11434";
+        const ollamaModels = process.env.CLOUDCONTROL_OLLAMA_MODELS?.split(",") || [];
+        for (const model of ollamaModels) {
+            const name = model.trim();
+            if (!name)
+                continue;
+            this.models.push({
+                name: `ollama/${name}`,
+                adapter: new OllamaAdapter(name, ollamaUrl),
+                traits: ["cheapest", "local"],
+                available: true,
+            });
+        }
+        // Set default: first available local model, or cheapest API model
+        const localModel = this.models.find((m) => m.traits.includes("local"));
+        const cheapApi = this.models.find((m) => m.name === "claude-haiku");
+        this.defaultModel = localModel?.name || cheapApi?.name || this.models[0]?.name || "";
+        console.log(`[router] Available models: ${this.models.map((m) => m.name).join(", ") || "none"}`);
+        console.log(`[router] Default model: ${this.defaultModel || "none"}`);
+    }
+    /**
+     * Select the best model for a task based on its modelHint.
+     */
+    select(modelHint) {
+        if (!modelHint || modelHint === "auto") {
+            return this.getByName(this.defaultModel);
+        }
+        // Specific model name — exact match
+        const exact = this.models.find((m) => m.name === modelHint && m.available);
+        if (exact) {
+            return { adapter: exact.adapter, name: exact.name };
+        }
+        // Trait-based hint — find best match
+        const trait = modelHint;
+        const candidates = this.models.filter((m) => m.available && m.traits.includes(trait));
+        if (candidates.length > 0) {
+            return { adapter: candidates[0].adapter, name: candidates[0].name };
+        }
+        console.log(`[router] No model matches hint "${modelHint}", using default "${this.defaultModel}"`);
+        return this.getByName(this.defaultModel);
+    }
+    getByName(name) {
+        const model = this.models.find((m) => m.name === name && m.available);
+        if (model)
+            return { adapter: model.adapter, name: model.name };
+        const fallback = this.models.find((m) => m.available);
+        if (fallback) {
+            console.log(`[router] Default "${name}" not available, falling back to "${fallback.name}"`);
+            return { adapter: fallback.adapter, name: fallback.name };
+        }
+        throw new Error("No AI models available. Install a CLI (claude, gemini, etc.), set ANTHROPIC_API_KEY, or configure Ollama.");
+    }
+    getDefault() {
+        return this.defaultModel || "none";
+    }
+    listModels() {
+        return this.models
+            .filter((m) => m.available)
+            .map((m) => ({ name: m.name, traits: m.traits }));
+    }
+}
+//# sourceMappingURL=model-router.js.map

package/dist/models/claude-code.d.ts

@@ -0,0 +1,15 @@
+import type { ExecutionResult } from "./claude.js";
+import { type SandboxConfig } from "../sandbox.js";
+export declare class ClaudeCodeAdapter {
+    private sandboxConfig;
+    constructor(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>;
+    private runClaude;
+}

package/dist/models/claude-code.js

@@ -0,0 +1,140 @@
+import { spawn } from "child_process";
+import { buildSandboxPrompt, getDefaultSandboxConfig, filterEnvironment, truncateOutput, } from "../sandbox.js";
+export class ClaudeCodeAdapter {
+    sandboxConfig;
+    constructor(sandboxConfig) {
+        this.sandboxConfig = sandboxConfig || getDefaultSandboxConfig();
+    }
+    async execute(task) {
+        const dialogue = [];
+        const startTime = Date.now();
+        // Build prompt with sandbox restrictions
+        const sandboxRules = buildSandboxPrompt(this.sandboxConfig);
+        let prompt = `## Task: ${task.title}\n`;
+        if (task.description)
+            prompt += `\n${task.description}\n`;
+        if (task.taskType)
+            prompt += `\nTask type: ${task.taskType}\n`;
+        if (task.processHint)
+            prompt += `\nProcess hint: ${task.processHint}\n`;
+        if (task.context) {
+            prompt += `\nContext:\n\`\`\`json\n${JSON.stringify(task.context, null, 2)}\n\`\`\`\n`;
+        }
+        if (task.humanContext) {
+            prompt += `\nHuman feedback from previous attempt:\n${task.humanContext}\n`;
+        }
+        prompt += `\nWhen you encounter something you cannot complete (CAPTCHA, phone verification, account creation, ambiguous decision), say: [HUMAN_REQUIRED]: <reason>\n`;
+        prompt += `\nWhen done, end with: [RESULT]: <brief summary>\n`;
+        prompt += sandboxRules;
+        dialogue.push({
+            role: "user",
+            content: prompt,
+            timestamp: new Date().toISOString(),
+        });
+        try {
+            const output = await this.runClaude(prompt);
+            dialogue.push({
+                role: "assistant",
+                content: output,
+                timestamp: new Date().toISOString(),
+            });
+            // Check for human required
+            const humanMatch = output.match(/\[HUMAN_REQUIRED\]:\s*(.*)/s);
+            if (humanMatch) {
+                return {
+                    success: false,
+                    dialogue,
+                    result: { raw_response: output },
+                    metadata: {
+                        model: "claude-code",
+                        tokens_used: 0,
+                        duration_ms: Date.now() - startTime,
+                    },
+                    humanRequired: {
+                        reason: humanMatch[1].trim(),
+                        context: output,
+                    },
+                };
+            }
+            const resultMatch = output.match(/\[RESULT\]:\s*(.*)/s);
+            const resultSummary = resultMatch
+                ? resultMatch[1].trim()
+                : output.slice(0, 500);
+            return {
+                success: true,
+                dialogue,
+                result: { summary: resultSummary, raw_response: output },
+                metadata: {
+                    model: "claude-code",
+                    tokens_used: 0,
+                    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: "claude-code",
+                    tokens_used: 0,
+                    duration_ms: Date.now() - startTime,
+                },
+            };
+        }
+    }
+    runClaude(prompt) {
+        return new Promise((resolve, reject) => {
+            // Filter environment — only pass allowed vars, strip secrets
+            const filteredEnv = filterEnvironment(process.env, this.sandboxConfig.allowedEnvVars);
+            const proc = spawn("claude", ["-p", prompt], {
+                stdio: ["ignore", "pipe", "pipe"],
+                env: filteredEnv,
+            });
+            let stdout = "";
+            let stderr = "";
+            const maxOutput = this.sandboxConfig.maxOutputBytes;
+            proc.stdout.on("data", (data) => {
+                stdout += data.toString();
+                // Kill process if output exceeds limit
+                if (Buffer.byteLength(stdout, "utf-8") > maxOutput * 1.1) {
+                    proc.kill();
+                    reject(new Error("Output exceeded maximum size limit"));
+                }
+            });
+            proc.stderr.on("data", (data) => {
+                stderr += data.toString();
+            });
+            proc.on("close", (code) => {
+                const truncatedOutput = truncateOutput(stdout.trim(), maxOutput);
+                if (code === 0) {
+                    resolve(truncatedOutput);
+                }
+                else {
+                    reject(new Error(`claude exited with code ${code}: ${stderr.slice(0, 500)}`));
+                }
+            });
+            proc.on("error", (err) => {
+                if (err.code === "ENOENT") {
+                    reject(new Error("Claude Code CLI not found. Install it or set ANTHROPIC_API_KEY to use the API adapter."));
+                }
+                else {
+                    reject(err);
+                }
+            });
+            // 5 minute timeout
+            setTimeout(() => {
+                proc.kill();
+                reject(new Error("Claude Code execution timed out (5m)"));
+            }, 5 * 60 * 1000);
+        });
+    }
+}
+//# sourceMappingURL=claude-code.js.map

package/dist/models/claude.d.ts

@@ -0,0 +1,34 @@
+import { type SandboxConfig } from "../sandbox.js";
+export interface ChatMessage {
+    role: "user" | "assistant" | "system";
+    content: string;
+    timestamp: string;
+}
+export interface ExecutionResult {
+    success: boolean;
+    dialogue: ChatMessage[];
+    result: Record<string, unknown>;
+    metadata: {
+        model: string;
+        tokens_used: number;
+        duration_ms: number;
+    };
+    humanRequired?: {
+        reason: string;
+        context: string;
+    };
+}
+export declare class ClaudeAdapter {
+    private client;
+    private model;
+    private sandboxConfig;
+    constructor(model?: 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/claude.js

@@ -0,0 +1,121 @@
+import Anthropic from "@anthropic-ai/sdk";
+import { buildSandboxPrompt, getDefaultSandboxConfig } from "../sandbox.js";
+export class ClaudeAdapter {
+    client;
+    model;
+    sandboxConfig;
+    constructor(model = "claude-sonnet-4-20250514", sandboxConfig) {
+        this.client = new Anthropic();
+        this.model = model;
+        this.sandboxConfig = sandboxConfig || getDefaultSandboxConfig();
+    }
+    async execute(task) {
+        const dialogue = [];
+        const startTime = Date.now();
+        let totalTokens = 0;
+        // Build system prompt with sandbox restrictions
+        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}`;
+        // Build user message with full context
+        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 this.client.messages.create({
+                model: this.model,
+                max_tokens: 4096,
+                system: systemPrompt,
+                messages: [{ role: "user", content: userMessage }],
+            });
+            const assistantContent = response.content
+                .filter((c) => c.type === "text")
+                .map((c) => c.text)
+                .join("\n");
+            totalTokens =
+                (response.usage?.input_tokens || 0) +
+                    (response.usage?.output_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,
+                    },
+                };
+            }
+            // Extract result
+            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=claude.js.map

package/dist/models/cli-adapter.d.ts

@@ -0,0 +1,48 @@
+import type { ExecutionResult } from "./claude.js";
+import { type SandboxConfig } from "../sandbox.js";
+export interface CliModelConfig {
+    /** Display name (e.g., "gemini", "claude-code", "aider") */
+    name: string;
+    /** Binary to execute (e.g., "claude", "gemini", "aider") */
+    command: string;
+    /** How to pass the prompt. Use {prompt} as placeholder. */
+    args: string[];
+    /** Environment variables to set for this CLI (merged with filtered env) */
+    env?: Record<string, string>;
+    /** Timeout in ms (default: 5 minutes) */
+    timeoutMs?: number;
+}
+/**
+ * Predefined CLI configurations for known tools.
+ * Add new CLIs here — no other code changes needed.
+ */
+export declare const KNOWN_CLIS: Record<string, Omit<CliModelConfig, "name">>;
+/**
+ * Generic CLI adapter — works with any AI CLI tool that accepts a prompt
+ * and writes output to stdout. Configure via CliModelConfig or use a
+ * predefined config from KNOWN_CLIS.
+ */
+export declare class CliAdapter {
+    private config;
+    private sandboxConfig;
+    constructor(config: CliModelConfig, 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>;
+    private taskId?;
+    setTaskId(taskId: string): void;
+    private runCli;
+}
+/**
+ * Parse CLI model definitions from an env var string.
+ * Format: "name:command:arg1,arg2;name2:command2:arg1,arg2"
+ * Example: "gemini:gemini:-p;aider:aider:--message,--yes-always,--no-git"
+ *
+ * If only a name is given (e.g., "gemini"), looks it up in KNOWN_CLIS.
+ */
+export declare function parseCliModels(envValue: string): CliModelConfig[];