@epic-cloudcontrol/daemon 0.2.0

package/dist/models/cli-adapter.js

@@ -0,0 +1,218 @@
+import { spawn } from "child_process";
+import { buildSandboxPrompt, getDefaultSandboxConfig, getSandboxedSpawnOptions, truncateOutput, } from "../sandbox.js";
+/**
+ * Predefined CLI configurations for known tools.
+ * Add new CLIs here — no other code changes needed.
+ */
+export const KNOWN_CLIS = {
+    "claude-code": {
+        command: "claude",
+        args: ["-p", "{prompt}"],
+    },
+    gemini: {
+        command: "gemini",
+        args: ["-p", "{prompt}"],
+    },
+    codex: {
+        command: "codex",
+        args: ["-p", "{prompt}"],
+    },
+    aider: {
+        command: "aider",
+        args: ["--message", "{prompt}", "--yes-always", "--no-git"],
+    },
+    goose: {
+        command: "goose",
+        args: ["run", "--text", "{prompt}"],
+    },
+};
+/**
+ * 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 class CliAdapter {
+    config;
+    sandboxConfig;
+    constructor(config, sandboxConfig) {
+        this.config = {
+            ...config,
+            env: config.env || {},
+            timeoutMs: config.timeoutMs || 5 * 60 * 1000,
+        };
+        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.runCli(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: this.config.name,
+                        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: this.config.name,
+                    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: this.config.name,
+                    tokens_used: 0,
+                    duration_ms: Date.now() - startTime,
+                },
+            };
+        }
+    }
+    taskId;
+    setTaskId(taskId) {
+        this.taskId = taskId;
+    }
+    runCli(prompt) {
+        return new Promise((resolve, reject) => {
+            // Get sandboxed environment (restricted PATH, isolated tmpdir)
+            const sandboxOpts = getSandboxedSpawnOptions(this.sandboxConfig, this.taskId);
+            const env = { ...sandboxOpts.env, ...this.config.env };
+            // Substitute {prompt} placeholder in args
+            const args = this.config.args.map((arg) => arg === "{prompt}" ? prompt : arg);
+            const proc = spawn(this.config.command, args, {
+                stdio: ["ignore", "pipe", "pipe"],
+                env,
+                cwd: sandboxOpts.cwd,
+            });
+            let stdout = "";
+            let stderr = "";
+            const maxOutput = this.sandboxConfig.maxOutputBytes;
+            proc.stdout.on("data", (data) => {
+                stdout += data.toString();
+                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(`${this.config.command} exited with code ${code}: ${stderr.slice(0, 500)}`));
+                }
+            });
+            proc.on("error", (err) => {
+                if (err.code === "ENOENT") {
+                    reject(new Error(`CLI "${this.config.command}" not found in PATH. Install it or use a different model.`));
+                }
+                else {
+                    reject(err);
+                }
+            });
+            setTimeout(() => {
+                proc.kill();
+                reject(new Error(`${this.config.command} execution timed out (${Math.round(this.config.timeoutMs / 1000)}s)`));
+            }, this.config.timeoutMs);
+        });
+    }
+}
+/**
+ * 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 function parseCliModels(envValue) {
+    const configs = [];
+    for (const entry of envValue.split(";")) {
+        const trimmed = entry.trim();
+        if (!trimmed)
+            continue;
+        const parts = trimmed.split(":");
+        const name = parts[0].trim();
+        // Check if it's a known CLI (just the name)
+        if (parts.length === 1 && KNOWN_CLIS[name]) {
+            configs.push({ name, ...KNOWN_CLIS[name] });
+            continue;
+        }
+        // Custom definition: name:command:args
+        if (parts.length >= 2) {
+            const command = parts[1].trim();
+            const args = parts.length >= 3
+                ? parts[2].split(",").map((a) => a.trim())
+                : ["-p", "{prompt}"];
+            // Ensure {prompt} is in args somewhere
+            if (!args.includes("{prompt}")) {
+                args.push("{prompt}");
+            }
+            configs.push({ name, command, args });
+        }
+    }
+    return configs;
+}
+//# sourceMappingURL=cli-adapter.js.map

package/dist/models/ollama.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Ollama model adapter for local LLM execution.
+ * Calls a locally-running Ollama server via its HTTP API.
+ *
+ * Data never leaves the machine — ideal for sensitive tasks.
+ *
+ * Requires: Ollama running locally (default: http://localhost:11434)
+ * Install: https://ollama.ai
+ */
+import type { ExecutionResult } from "./claude.js";
+import { type SandboxConfig } from "../sandbox.js";
+export declare class OllamaAdapter {
+    private baseUrl;
+    private model;
+    private sandboxConfig;
+    constructor(model?: string, baseUrl?: 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/ollama.js

@@ -0,0 +1,139 @@
+/**
+ * Ollama model adapter for local LLM execution.
+ * Calls a locally-running Ollama server via its HTTP API.
+ *
+ * Data never leaves the machine — ideal for sensitive tasks.
+ *
+ * Requires: Ollama running locally (default: http://localhost:11434)
+ * Install: https://ollama.ai
+ */
+import { buildSandboxPrompt, getDefaultSandboxConfig } from "../sandbox.js";
+export class OllamaAdapter {
+    baseUrl;
+    model;
+    sandboxConfig;
+    constructor(model = "llama3", baseUrl = "http://localhost:11434", sandboxConfig) {
+        this.model = model;
+        this.baseUrl = baseUrl;
+        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
+        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 {
+            // Call Ollama chat API
+            const response = await fetch(`${this.baseUrl}/api/chat`, {
+                method: "POST",
+                headers: { "content-type": "application/json" },
+                body: JSON.stringify({
+                    model: this.model,
+                    messages: [
+                        { role: "system", content: systemPrompt },
+                        { role: "user", content: userMessage },
+                    ],
+                    stream: false,
+                    options: {
+                        num_predict: 4096,
+                    },
+                }),
+            });
+            if (!response.ok) {
+                const text = await response.text();
+                throw new Error(`Ollama API error ${response.status}: ${text.slice(0, 200)}`);
+            }
+            const data = await response.json();
+            const assistantContent = data.message?.content || "";
+            totalTokens = (data.prompt_eval_count || 0) + (data.eval_count || 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: `ollama/${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: `ollama/${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: `ollama/${this.model}`,
+                    tokens_used: totalTokens,
+                    duration_ms: Date.now() - startTime,
+                },
+            };
+        }
+    }
+}
+//# sourceMappingURL=ollama.js.map

package/dist/multi-profile.d.ts

@@ -0,0 +1,6 @@
+export declare function startAllProfiles(overrides: {
+    workerType?: string;
+    capabilities?: string[];
+    pollInterval?: number;
+    model?: string;
+}): Promise<() => void>;

package/dist/multi-profile.js

@@ -0,0 +1,137 @@
+import os from "os";
+import { loadConfig } from "./config.js";
+import { listProfiles } from "./profile.js";
+import { TaskExecutor } from "./task-executor.js";
+import { fetchWithRetry } from "./retry.js";
+import { DAEMON_VERSION } from "./version.js";
+export async function startAllProfiles(overrides) {
+    const profiles = listProfiles();
+    if (profiles.length === 0) {
+        console.error("No profiles found. Run 'cloudcontrol login' first.");
+        process.exit(1);
+    }
+    console.log(`\n┌─────────────────────────────────────┐`);
+    console.log(`│       CloudControl Daemon v${DAEMON_VERSION.padEnd(7)}│`);
+    console.log(`├─────────────────────────────────────┤`);
+    console.log(`│  Mode:    multi-profile (${String(profiles.length)} co.)${" ".repeat(Math.max(0, 7 - String(profiles.length).length))}│`);
+    console.log(`│  Platform: ${(os.platform() + "/" + os.arch()).padEnd(25)}│`);
+    console.log(`└─────────────────────────────────────┘\n`);
+    const workers = [];
+    for (const { name, profile } of profiles) {
+        const config = loadConfig({
+            profileName: name,
+            workerType: overrides.workerType,
+            capabilities: overrides.capabilities,
+            pollInterval: overrides.pollInterval,
+            model: overrides.model,
+        });
+        if (!config.apiKey) {
+            console.log(`  [${name}] Skipping — no API key`);
+            continue;
+        }
+        const executor = new TaskExecutor(config);
+        const pw = {
+            profileName: name,
+            teamName: profile.teamName || name,
+            config,
+            executor,
+            workerId: null,
+            pollTimer: null,
+            heartbeatTimer: null,
+            executing: false,
+        };
+        // Register worker
+        try {
+            const res = await fetchWithRetry(`${config.apiUrl}/api/workers`, {
+                method: "POST",
+                headers: {
+                    authorization: `Bearer ${config.apiKey}`,
+                    "content-type": "application/json",
+                },
+                body: JSON.stringify({
+                    name: config.workerName,
+                    workerType: config.workerType,
+                    connectionMode: "poll",
+                    platform: os.platform(),
+                    capabilities: config.capabilities,
+                    taskTypeFilter: config.taskTypeFilter,
+                    metadata: {
+                        arch: os.arch(),
+                        nodeVersion: process.version,
+                        daemonVersion: DAEMON_VERSION,
+                        availableModels: executor.getAvailableModels(),
+                        multiProfile: true,
+                    },
+                }),
+            }, { maxRetries: 3, baseDelayMs: 2000 });
+            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)}...`);
+        }
+        catch (err) {
+            console.error(`  [${pw.teamName}] Registration failed: ${err.message}`);
+            continue;
+        }
+        // Set up polling
+        const poll = async () => {
+            if (pw.executing)
+                return;
+            try {
+                const tasks = await executor.pollTasks();
+                if (tasks.length > 0) {
+                    pw.executing = true;
+                    try {
+                        sendHeartbeat(pw, "busy");
+                        const task = await executor.claimTask(tasks[0].id);
+                        if (task) {
+                            console.log(`  [${pw.teamName}] Claimed: ${task.title}`);
+                            await executor.executeTask(task);
+                        }
+                    }
+                    catch (err) {
+                        console.error(`  [${pw.teamName}] Execution error: ${err.message}`);
+                    }
+                    finally {
+                        pw.executing = false;
+                        sendHeartbeat(pw, "online");
+                    }
+                }
+            }
+            catch { /* non-fatal */ }
+        };
+        pw.pollTimer = setInterval(poll, config.pollInterval);
+        pw.heartbeatTimer = setInterval(() => sendHeartbeat(pw, "online"), config.heartbeatInterval);
+        poll();
+        workers.push(pw);
+    }
+    if (workers.length === 0) {
+        console.error("\nNo workers started. Check your profiles.");
+        process.exit(1);
+    }
+    console.log(`\nRunning ${workers.length} worker(s). Press Ctrl+C to stop.\n`);
+    return () => {
+        for (const pw of workers) {
+            if (pw.pollTimer)
+                clearInterval(pw.pollTimer);
+            if (pw.heartbeatTimer)
+                clearInterval(pw.heartbeatTimer);
+        }
+    };
+}
+async function sendHeartbeat(pw, status) {
+    if (!pw.workerId)
+        return;
+    try {
+        await fetchWithRetry(`${pw.config.apiUrl}/api/workers/heartbeat`, {
+            method: "POST",
+            headers: {
+                authorization: `Bearer ${pw.config.apiKey}`,
+                "content-type": "application/json",
+            },
+            body: JSON.stringify({ workerId: pw.workerId, status }),
+        }, { maxRetries: 1, baseDelayMs: 1000 });
+    }
+    catch { /* non-fatal */ }
+}
+//# sourceMappingURL=multi-profile.js.map

package/dist/profile.d.ts

@@ -0,0 +1,27 @@
+export interface Profile {
+    apiUrl: string;
+    apiKey: string;
+    workerName?: string;
+    teamName?: string;
+}
+export declare function getConfigDir(): string;
+/**
+ * Load a named profile. Falls back to "default" if name not specified.
+ */
+export declare function loadProfile(name?: string): Profile | null;
+/**
+ * Save a named profile.
+ */
+export declare function saveProfile(profile: Profile, name?: string): void;
+/**
+ * List all saved profiles.
+ */
+export declare function listProfiles(): Array<{
+    name: string;
+    profile: Profile;
+}>;
+/**
+ * Delete a named profile.
+ */
+export declare function deleteProfile(name: string): boolean;
+export declare function profileExists(name?: string): boolean;

package/dist/profile.js

@@ -0,0 +1,97 @@
+import fs from "fs";
+import path from "path";
+import os from "os";
+const CONFIG_DIR = path.join(os.homedir(), ".cloudcontrol");
+const PROFILES_DIR = path.join(CONFIG_DIR, "profiles");
+const DEFAULT_CONFIG = path.join(CONFIG_DIR, "config.json");
+export function getConfigDir() {
+    return CONFIG_DIR;
+}
+function getProfilePath(name) {
+    if (name === "default")
+        return DEFAULT_CONFIG;
+    return path.join(PROFILES_DIR, `${name}.json`);
+}
+/**
+ * Load a named profile. Falls back to "default" if name not specified.
+ */
+export function loadProfile(name) {
+    const profileName = name || "default";
+    const filePath = getProfilePath(profileName);
+    try {
+        if (!fs.existsSync(filePath)) {
+            // Fall back to default if named profile doesn't exist
+            if (profileName !== "default" && fs.existsSync(DEFAULT_CONFIG)) {
+                return null; // Don't fall back silently — profile was explicitly requested
+            }
+            if (!fs.existsSync(DEFAULT_CONFIG))
+                return null;
+            const raw = fs.readFileSync(DEFAULT_CONFIG, "utf-8");
+            return JSON.parse(raw);
+        }
+        const raw = fs.readFileSync(filePath, "utf-8");
+        return JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Save a named profile.
+ */
+export function saveProfile(profile, name) {
+    const profileName = name || "default";
+    if (!fs.existsSync(CONFIG_DIR)) {
+        fs.mkdirSync(CONFIG_DIR, { recursive: true, mode: 0o700 });
+    }
+    if (profileName !== "default" && !fs.existsSync(PROFILES_DIR)) {
+        fs.mkdirSync(PROFILES_DIR, { recursive: true, mode: 0o700 });
+    }
+    const filePath = getProfilePath(profileName);
+    fs.writeFileSync(filePath, JSON.stringify(profile, null, 2) + "\n", {
+        mode: 0o600,
+    });
+}
+/**
+ * List all saved profiles.
+ */
+export function listProfiles() {
+    const profiles = [];
+    // Default profile
+    if (fs.existsSync(DEFAULT_CONFIG)) {
+        try {
+            const raw = fs.readFileSync(DEFAULT_CONFIG, "utf-8");
+            profiles.push({ name: "default", profile: JSON.parse(raw) });
+        }
+        catch { /* skip corrupt */ }
+    }
+    // Named profiles
+    if (fs.existsSync(PROFILES_DIR)) {
+        for (const file of fs.readdirSync(PROFILES_DIR)) {
+            if (!file.endsWith(".json"))
+                continue;
+            const name = file.replace(/\.json$/, "");
+            try {
+                const raw = fs.readFileSync(path.join(PROFILES_DIR, file), "utf-8");
+                profiles.push({ name, profile: JSON.parse(raw) });
+            }
+            catch { /* skip corrupt */ }
+        }
+    }
+    return profiles;
+}
+/**
+ * Delete a named profile.
+ */
+export function deleteProfile(name) {
+    const filePath = getProfilePath(name);
+    if (fs.existsSync(filePath)) {
+        fs.unlinkSync(filePath);
+        return true;
+    }
+    return false;
+}
+export function profileExists(name) {
+    return fs.existsSync(getProfilePath(name || "default"));
+}
+//# sourceMappingURL=profile.js.map

package/dist/retry.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Exponential backoff retry utility for the daemon.
+ * Retries failed operations with increasing delays and jitter.
+ */
+interface RetryOptions {
+    maxRetries?: number;
+    baseDelayMs?: number;
+    maxDelayMs?: number;
+    onRetry?: (attempt: number, error: Error) => void;
+}
+export declare function withRetry<T>(fn: () => Promise<T>, options?: RetryOptions): Promise<T>;
+/**
+ * Fetch wrapper with retry. Returns the Response object.
+ * Throws on non-OK responses so retry can catch them.
+ */
+export declare function fetchWithRetry(url: string, init: RequestInit, options?: RetryOptions): Promise<Response>;
+export {};