@epic-cloudcontrol/daemon 0.2.1 → 0.3.0

package/dist/__tests__/config.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__tests__/config.test.js

@@ -0,0 +1,26 @@
+import { describe, it, expect } from "vitest";
+import { loadConfig } from "../config.js";
+describe("loadConfig", () => {
+    it("returns default values when no overrides", () => {
+        const config = loadConfig({});
+        expect(config.workerType).toBe("daemon");
+        expect(config.pollInterval).toBe(15000);
+        expect(config.heartbeatInterval).toBe(30000);
+        expect(config.capabilities).toContain("ai_execution");
+    });
+    it("applies overrides", () => {
+        const config = loadConfig({
+            apiUrl: "https://custom.example.com",
+            workerType: "cli",
+            pollInterval: 5000,
+        });
+        expect(config.apiUrl).toBe("https://custom.example.com");
+        expect(config.workerType).toBe("cli");
+        expect(config.pollInterval).toBe(5000);
+    });
+    it("capabilities default includes standard set", () => {
+        const config = loadConfig({});
+        expect(config.capabilities).toEqual(expect.arrayContaining(["browser", "filesystem", "shell", "ai_execution"]));
+    });
+});
+//# sourceMappingURL=config.test.js.map

package/dist/__tests__/model-router.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__tests__/model-router.test.js

@@ -0,0 +1,59 @@
+import { describe, it, expect } from "vitest";
+import { ModelRouter } from "../model-router.js";
+describe("ModelRouter", () => {
+    it("initializes and detects available models", () => {
+        const router = new ModelRouter();
+        const models = router.listModels();
+        expect(Array.isArray(models)).toBe(true);
+    });
+    it("has a default model string", () => {
+        const router = new ModelRouter();
+        const defaultModel = router.getDefault();
+        // Returns "none" when no models are available, or a real model name
+        expect(typeof defaultModel).toBe("string");
+        expect(defaultModel.length).toBeGreaterThan(0);
+    });
+    it("select returns a result or throws when no models available", () => {
+        const router = new ModelRouter();
+        const models = router.listModels();
+        if (models.length === 0) {
+            // No models available — select should throw
+            expect(() => router.select("auto")).toThrow("No AI models available");
+        }
+        else {
+            const result = router.select("auto");
+            expect(result.name).toBe(router.getDefault());
+        }
+    });
+    it("select with null behaves same as auto", () => {
+        const router = new ModelRouter();
+        const models = router.listModels();
+        if (models.length === 0) {
+            expect(() => router.select(null)).toThrow("No AI models available");
+        }
+        else {
+            const result = router.select(null);
+            expect(result.name).toBe(router.getDefault());
+        }
+    });
+    it("falls back to default for unknown hint when models exist", () => {
+        const router = new ModelRouter();
+        const models = router.listModels();
+        if (models.length === 0) {
+            expect(() => router.select("nonexistent-model-xyz")).toThrow("No AI models available");
+        }
+        else {
+            const result = router.select("nonexistent-model-xyz");
+            expect(result.name).toBeTruthy();
+        }
+    });
+    it("selects by trait if available", () => {
+        const router = new ModelRouter();
+        const models = router.listModels();
+        if (models.some((m) => m.traits.includes("code"))) {
+            const result = router.select("code");
+            expect(result.name).toBeTruthy();
+        }
+    });
+});
+//# sourceMappingURL=model-router.test.js.map

package/dist/__tests__/profile.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__tests__/profile.test.js

@@ -0,0 +1,53 @@
+import { describe, it, expect, afterEach } from "vitest";
+import { saveProfile, loadProfile, listProfiles, deleteProfile, profileExists, } from "../profile.js";
+describe("profile", () => {
+    const TEST_PROFILE = "vitest-temp-profile";
+    afterEach(() => {
+        try {
+            deleteProfile(TEST_PROFILE);
+        }
+        catch { }
+    });
+    it("saves and loads a named profile", () => {
+        saveProfile({
+            apiUrl: "https://test.example.com",
+            apiKey: "cc_test123",
+            workerName: "test-worker",
+            teamName: "Test Team",
+        }, TEST_PROFILE);
+        const loaded = loadProfile(TEST_PROFILE);
+        expect(loaded).not.toBeNull();
+        expect(loaded.apiUrl).toBe("https://test.example.com");
+        expect(loaded.apiKey).toBe("cc_test123");
+        expect(loaded.workerName).toBe("test-worker");
+        expect(loaded.teamName).toBe("Test Team");
+    });
+    it("returns null for non-existent profile", () => {
+        const loaded = loadProfile("nonexistent-profile-xyz");
+        expect(loaded).toBeNull();
+    });
+    it("lists profiles including test profile", () => {
+        saveProfile({
+            apiUrl: "https://test.example.com",
+            apiKey: "cc_test123",
+        }, TEST_PROFILE);
+        const profiles = listProfiles();
+        const found = profiles.find((p) => p.name === TEST_PROFILE);
+        expect(found).toBeDefined();
+        expect(found.profile.apiUrl).toBe("https://test.example.com");
+    });
+    it("deletes a profile", () => {
+        saveProfile({
+            apiUrl: "https://test.example.com",
+            apiKey: "cc_test123",
+        }, TEST_PROFILE);
+        expect(profileExists(TEST_PROFILE)).toBe(true);
+        const deleted = deleteProfile(TEST_PROFILE);
+        expect(deleted).toBe(true);
+        expect(profileExists(TEST_PROFILE)).toBe(false);
+    });
+    it("profileExists returns false for non-existent", () => {
+        expect(profileExists("nonexistent-xyz")).toBe(false);
+    });
+});
+//# sourceMappingURL=profile.test.js.map

package/dist/__tests__/sandbox.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__tests__/sandbox.test.js

@@ -0,0 +1,78 @@
+import { describe, it, expect } from "vitest";
+import { getDefaultSandboxConfig, buildSandboxPrompt, filterEnvironment, truncateOutput, createTaskTmpDir, cleanupTaskTmpDir, getRestrictedPath, } from "../sandbox.js";
+import { existsSync } from "fs";
+describe("sandbox", () => {
+    describe("getDefaultSandboxConfig", () => {
+        it("returns config with blocked commands", () => {
+            const config = getDefaultSandboxConfig();
+            expect(config.blockedCommands.length).toBeGreaterThan(0);
+            expect(config.blockedCommands).toContain("rm -rf /");
+            expect(config.blockedCommands).toContain("sudo");
+        });
+        it("returns config with blocked paths", () => {
+            const config = getDefaultSandboxConfig();
+            expect(config.blockedPaths.length).toBeGreaterThan(0);
+            expect(config.blockedPaths).toContain("/etc/shadow");
+        });
+    });
+    describe("buildSandboxPrompt", () => {
+        it("generates a non-empty prompt string", () => {
+            const config = getDefaultSandboxConfig();
+            const prompt = buildSandboxPrompt(config);
+            expect(prompt.length).toBeGreaterThan(100);
+            // The heading is "## Security Restrictions" (mixed case)
+            expect(prompt).toContain("Security Restrictions");
+        });
+    });
+    describe("filterEnvironment", () => {
+        it("filters to only allowed variables", () => {
+            const env = {
+                HOME: "/home/user",
+                PATH: "/usr/bin",
+                SECRET_KEY: "should-be-removed",
+                AWS_ACCESS_KEY: "should-be-removed",
+            };
+            const filtered = filterEnvironment(env, ["HOME", "PATH"]);
+            expect(filtered.HOME).toBe("/home/user");
+            expect(filtered.PATH).toBe("/usr/bin");
+            expect(filtered.SECRET_KEY).toBeUndefined();
+            expect(filtered.AWS_ACCESS_KEY).toBeUndefined();
+        });
+    });
+    describe("truncateOutput", () => {
+        it("returns short output unchanged", () => {
+            expect(truncateOutput("hello", 1000)).toBe("hello");
+        });
+        it("truncates long output", () => {
+            const long = "x".repeat(2000);
+            const result = truncateOutput(long, 100);
+            expect(result.length).toBeLessThan(500);
+            expect(result).toContain("OUTPUT TRUNCATED");
+        });
+    });
+    describe("createTaskTmpDir / cleanupTaskTmpDir", () => {
+        const testTaskId = "test-1234-abcd-5678";
+        it("creates and cleans up temp directory", () => {
+            const dir = createTaskTmpDir(testTaskId);
+            expect(existsSync(dir)).toBe(true);
+            // taskId.slice(0,8) = "test-123", so dir ends with "cloudcontrol-test-123"
+            expect(dir).toContain("cloudcontrol-test-123");
+            cleanupTaskTmpDir(testTaskId);
+            expect(existsSync(dir)).toBe(false);
+        });
+    });
+    describe("getRestrictedPath", () => {
+        it("includes standard system directories", () => {
+            const restricted = getRestrictedPath();
+            expect(restricted).toContain("/usr/bin");
+            expect(restricted).toContain("/bin");
+        });
+        it("does not include arbitrary non-system directories", () => {
+            const restricted = getRestrictedPath();
+            // Should not include unrelated user dirs like Documents, Downloads, etc.
+            expect(restricted).not.toContain("/Documents");
+            expect(restricted).not.toContain("/Downloads");
+        });
+    });
+});
+//# sourceMappingURL=sandbox.test.js.map

package/dist/__tests__/version.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__tests__/version.test.js

@@ -0,0 +1,11 @@
+import { describe, it, expect } from "vitest";
+import { DAEMON_VERSION } from "../version.js";
+describe("version", () => {
+    it("reads version from package.json", () => {
+        expect(DAEMON_VERSION).toMatch(/^\d+\.\d+\.\d+$/);
+    });
+    it("is not fallback version", () => {
+        expect(DAEMON_VERSION).not.toBe("0.0.0");
+    });
+});
+//# sourceMappingURL=version.test.js.map

package/dist/browser.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Optional Playwright browser automation for process steps.
+ * Only loaded when a browser step is encountered.
+ * Fails gracefully if Playwright is not installed.
+ */
+import type { ProcessStep } from "./step-runner.js";
+export declare function executeBrowserStep(step: ProcessStep): Promise<string>;

package/dist/browser.js

@@ -0,0 +1,56 @@
+/**
+ * Optional Playwright browser automation for process steps.
+ * Only loaded when a browser step is encountered.
+ * Fails gracefully if Playwright is not installed.
+ */
+import { createLogger } from "./logger.js";
+const log = createLogger("browser");
+export async function executeBrowserStep(step) {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const { chromium } = await import("playwright");
+    const browser = await chromium.launch({ headless: true });
+    const page = await browser.newPage();
+    try {
+        switch (step.action) {
+            case "navigate": {
+                if (!step.target)
+                    throw new Error("Navigate step requires a target URL");
+                log.info(`Navigating to ${step.target}`);
+                await page.goto(step.target, { timeout: 30000 });
+                const title = await page.title();
+                return `Navigated to ${step.target} — page title: "${title}"`;
+            }
+            case "click": {
+                if (!step.selector)
+                    throw new Error("Click step requires a selector");
+                log.info(`Clicking ${step.selector}`);
+                await page.click(step.selector, { timeout: 10000 });
+                return `Clicked ${step.selector}`;
+            }
+            case "fill": {
+                if (!step.selector || !step.target)
+                    throw new Error("Fill step requires selector and target (value)");
+                log.info(`Filling ${step.selector}`);
+                await page.fill(step.selector, step.target);
+                return `Filled ${step.selector} with value`;
+            }
+            case "screenshot": {
+                const path = `/tmp/cloudcontrol-screenshot-${Date.now()}.png`;
+                await page.screenshot({ path });
+                return `Screenshot saved to ${path}`;
+            }
+            default: {
+                if (step.target) {
+                    await page.goto(step.target, { timeout: 30000 });
+                    const title = await page.title();
+                    return `Navigated to ${step.target} — page title: "${title}"`;
+                }
+                return `Browser step "${step.id}" completed (no specific action)`;
+            }
+        }
+    }
+    finally {
+        await browser.close();
+    }
+}
+//# sourceMappingURL=browser.js.map

package/dist/cli.js

@@ -17,6 +17,8 @@ import { ModelRouter } from "./model-router.js";
 import { fetchWithRetry } from "./retry.js";
 import { DAEMON_VERSION } from "./version.js";
 import { install, uninstall, serviceStatus, getLogPath, getErrorLogPath, detectPlatform } from "./service-manager.js";
+import { createLogger } from "./logger.js";
+const log = createLogger("daemon");
 const program = new Command();
 program
     .name("cloudcontrol")
@@ -299,9 +301,11 @@ program
     console.log(`Default: ${router.getDefault()}`);
     console.log("");
     console.log("Add models:");
-    console.log("  Install a CLI:    npm install -g @google/gemini-cli");
-    console.log("  API key:          export ANTHROPIC_API_KEY=sk-ant-...");
+    console.log("  Anthropic:        export ANTHROPIC_API_KEY=sk-ant-...");
+    console.log("  OpenAI:           export OPENAI_API_KEY=sk-...");
+    console.log("  Google:           export GOOGLE_API_KEY=...");
     console.log("  Ollama:           export CLOUDCONTROL_OLLAMA_MODELS=llama3,mistral");
+    console.log("  CLI tool:         npm install -g @google/gemini-cli");
     console.log("  Custom CLI:       export CLOUDCONTROL_CLI_MODELS=\"mycli:mybinary:-p\"");
 });
 // ── status ────────────────────────────────────────────
@@ -377,7 +381,7 @@ program
             model: opts.model,
         });
         const stop = () => {
-            console.log("\n[daemon] Shutting down all workers...");
+            log.info("Shutting down all workers...");
             shutdown();
             process.exit(0);
         };
@@ -417,7 +421,7 @@ program
 └─────────────────────────────────────┘
 `);
     // Register worker (with retry)
-    console.log("[daemon] Registering worker...");
+    log.info("Registering worker...");
     let worker;
     try {
         const registerRes = await fetchWithRetry(`${cfg.apiUrl}/api/workers`, {
@@ -444,22 +448,22 @@ program
             maxRetries: 5,
             baseDelayMs: 2000,
             onRetry: (attempt, err) => {
-                console.log(`[daemon] Registration retry ${attempt}: ${err.message}`);
+                log.info(`Registration retry ${attempt}: ${err.message}`);
             },
         });
         ({ worker } = await registerRes.json());
     }
     catch (err) {
-        console.error(`[daemon] Failed to register after retries: ${err.message}`);
+        log.error(`Failed to register after retries: ${err.message}`);
         process.exit(1);
     }
-    console.log(`[daemon] Registered as worker ${worker.id}`);
+    log.info(`Registered as worker ${worker.id}`);
     executor.setWorkerId(worker.id);
     // Track if currently executing (one task at a time)
     let executing = false;
     async function executeTask(taskId) {
         if (executing) {
-            console.log(`[daemon] Already executing, skipping task ${taskId.slice(0, 8)}`);
+            log.info(`Already executing, skipping task ${taskId.slice(0, 8)}`);
             return;
         }
         executing = true;
@@ -468,11 +472,11 @@ program
             const task = await executor.claimTask(taskId);
             if (!task)
                 return;
-            console.log(`[daemon] Claimed: ${task.title}`);
+            log.info(`Claimed: ${task.title}`);
             await executor.executeTask(task);
         }
         catch (err) {
-            console.error(`[daemon] Execution error:`, err.message);
+            log.error(`Execution error: ${err.message}`);
         }
         finally {
             executing = false;
@@ -500,7 +504,7 @@ program
         try {
             const pending = await executor.pollTasks();
             if (pending.length > 0) {
-                console.log(`[daemon] Found ${pending.length} pending task(s)`);
+                log.info(`Found ${pending.length} pending task(s)`);
                 await executeTask(pending[0].id);
             }
         }
@@ -512,14 +516,14 @@ program
     const heartbeatTimer = setInterval(() => sendHeartbeat(), cfg.heartbeatInterval);
     pollForTasks();
     const shutdown = () => {
-        console.log("\n[daemon] Shutting down...");
+        log.info("Shutting down...");
         clearInterval(pollTimer);
         clearInterval(heartbeatTimer);
         process.exit(0);
     };
     process.on("SIGINT", shutdown);
     process.on("SIGTERM", shutdown);
-    console.log(`[daemon] Running. Polling every ${cfg.pollInterval / 1000}s. Press Ctrl+C to stop.`);
+    log.info(`Running. Polling every ${cfg.pollInterval / 1000}s. Press Ctrl+C to stop.`);
 });
 program.parse();
 //# sourceMappingURL=cli.js.map

package/dist/logger.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Minimal structured logger for the CloudControl daemon.
+ * - JSON output when NODE_ENV=production or CLOUDCONTROL_LOG_FORMAT=json
+ * - Human-readable colored output otherwise
+ * - No external dependencies
+ */
+export declare function createLogger(prefix: string): {
+    debug: (msg: string, meta?: Record<string, unknown>) => void;
+    info: (msg: string, meta?: Record<string, unknown>) => void;
+    warn: (msg: string, meta?: Record<string, unknown>) => void;
+    error: (msg: string, meta?: Record<string, unknown>) => void;
+};
+export type Logger = ReturnType<typeof createLogger>;

package/dist/logger.js

@@ -0,0 +1,64 @@
+/**
+ * Minimal structured logger for the CloudControl daemon.
+ * - JSON output when NODE_ENV=production or CLOUDCONTROL_LOG_FORMAT=json
+ * - Human-readable colored output otherwise
+ * - No external dependencies
+ */
+const LEVEL_PRIORITY = {
+    debug: 0,
+    info: 1,
+    warn: 2,
+    error: 3,
+};
+const LEVEL_COLORS = {
+    debug: "\x1b[90m",
+    info: "\x1b[36m",
+    warn: "\x1b[33m",
+    error: "\x1b[31m",
+};
+const RESET = "\x1b[0m";
+function isJsonMode() {
+    return process.env.NODE_ENV === "production" || process.env.CLOUDCONTROL_LOG_FORMAT === "json";
+}
+function getMinLevel() {
+    return process.env.CLOUDCONTROL_LOG_LEVEL || "info";
+}
+function shouldLog(level) {
+    return LEVEL_PRIORITY[level] >= LEVEL_PRIORITY[getMinLevel()];
+}
+function write(level, prefix, message, meta) {
+    if (!shouldLog(level))
+        return;
+    if (isJsonMode()) {
+        const entry = {
+            timestamp: new Date().toISOString(),
+            level,
+            component: prefix,
+            message,
+        };
+        if (meta)
+            entry.meta = meta;
+        process.stderr.write(JSON.stringify(entry) + "\n");
+    }
+    else {
+        const color = LEVEL_COLORS[level];
+        const ts = new Date().toISOString().slice(11, 19);
+        const metaStr = meta ? ` ${JSON.stringify(meta)}` : "";
+        const line = `${color}${ts}${RESET} [${prefix}] ${message}${metaStr}`;
+        if (level === "error") {
+            console.error(line);
+        }
+        else {
+            console.log(line);
+        }
+    }
+}
+export function createLogger(prefix) {
+    return {
+        debug: (msg, meta) => write("debug", prefix, msg, meta),
+        info: (msg, meta) => write("info", prefix, msg, meta),
+        warn: (msg, meta) => write("warn", prefix, msg, meta),
+        error: (msg, meta) => write("error", prefix, msg, meta),
+    };
+}
+//# sourceMappingURL=logger.js.map

package/dist/mcp-server.js

@@ -29,6 +29,8 @@ import { z } from "zod";
 import os from "os";
 import { DAEMON_VERSION } from "./version.js";
 import { loadProfile, listProfiles } from "./profile.js";
+import { createLogger } from "./logger.js";
+const log = createLogger("mcp");
 const profileName = process.env.CLOUDCONTROL_PROFILE;
 const profile = profileName ? loadProfile(profileName) : null;
 let API_URL = process.env.CLOUDCONTROL_API_URL || profile?.apiUrl || "http://localhost:3000";
@@ -498,25 +500,25 @@ server.resource("cloudcontrol://health", "cloudcontrol://health", async () => {
 async function main() {
     try {
         workerId = await registerWorker();
-        console.error(`[mcp] Registered as worker ${workerId} (${WORKER_NAME})`);
+        log.info(`Registered as worker ${workerId} (${WORKER_NAME})`);
     }
     catch (err) {
-        console.error(`[mcp] Worker registration failed: ${err.message}`);
+        log.error(`Worker registration failed: ${err.message}`);
     }
     // Auto-discover new companies on startup (non-blocking)
     refreshProfiles().then((lines) => {
         const newLines = lines.filter((l) => l.startsWith("✓"));
         if (newLines.length > 0) {
-            console.error(`[mcp] Auto-refresh: discovered ${newLines.length} new company(s)`);
+            log.info(`Auto-refresh: discovered ${newLines.length} new company(s)`);
             for (const l of newLines)
-                console.error(`[mcp]   ${l}`);
+                log.info(l);
         }
     }).catch(() => { });
     const heartbeatTimer = setInterval(sendHeartbeat, 30_000);
     const transport = new StdioServerTransport();
     await server.connect(transport);
-    console.error("[mcp] CloudControl MCP server running");
+    log.info("CloudControl MCP server running");
     process.on("SIGINT", () => { clearInterval(heartbeatTimer); process.exit(0); });
 }
-main().catch((err) => { console.error("[mcp] Fatal:", err); process.exit(1); });
+main().catch((err) => { log.error("Fatal:", { error: String(err) }); process.exit(1); });
 //# sourceMappingURL=mcp-server.js.map

package/dist/model-router.js

@@ -1,7 +1,11 @@
 import { ClaudeAdapter } from "./models/claude.js";
+import { OpenAIAdapter } from "./models/openai.js";
+import { GeminiAPIAdapter } from "./models/gemini-api.js";
 import { OllamaAdapter } from "./models/ollama.js";
 import { CliAdapter, KNOWN_CLIS, parseCliModels } from "./models/cli-adapter.js";
 import { execSync } from "child_process";
+import { createLogger } from "./logger.js";
+const log = createLogger("router");
 function isCommandInstalled(command) {
     try {
         execSync(`which ${command}`, { stdio: "ignore" });
@@ -45,7 +49,39 @@ export class ModelRouter {
                 available: true,
             });
         }
-        // 2. Auto-detect installed CLIs from KNOWN_CLIS
+        // 2. OpenAI API models (require OPENAI_API_KEY)
+        const openaiKey = process.env.OPENAI_API_KEY;
+        if (openaiKey && openaiKey.length > 0) {
+            this.models.push({
+                name: "gpt-4o",
+                adapter: new OpenAIAdapter("gpt-4o", openaiKey),
+                traits: ["smartest", "code", "vision"],
+                available: true,
+            });
+            this.models.push({
+                name: "gpt-4o-mini",
+                adapter: new OpenAIAdapter("gpt-4o-mini", openaiKey),
+                traits: ["cheapest", "fastest"],
+                available: true,
+            });
+        }
+        // 3. Google Gemini API models (require GOOGLE_API_KEY)
+        const googleKey = process.env.GOOGLE_API_KEY;
+        if (googleKey && googleKey.length > 0) {
+            this.models.push({
+                name: "gemini-pro",
+                adapter: new GeminiAPIAdapter("gemini-2.5-pro", googleKey),
+                traits: ["smartest", "code", "vision"],
+                available: true,
+            });
+            this.models.push({
+                name: "gemini-flash",
+                adapter: new GeminiAPIAdapter("gemini-2.5-flash", googleKey),
+                traits: ["cheapest", "fastest"],
+                available: true,
+            });
+        }
+        // 5. Auto-detect installed CLIs from KNOWN_CLIS
         const cliTraits = {
             "claude-code": ["smartest", "code", "local"],
             gemini: ["smartest", "code", "local"],
@@ -63,7 +99,7 @@ export class ModelRouter {
                 });
             }
         }
-        // 3. Custom CLI models from env var
+        // 6. 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;
@@ -81,7 +117,7 @@ export class ModelRouter {
                 });
             }
         }
-        // 4. Ollama models
+        // 7. Ollama models
         const ollamaUrl = process.env.OLLAMA_URL || "http://localhost:11434";
         const ollamaModels = process.env.CLOUDCONTROL_OLLAMA_MODELS?.split(",") || [];
         for (const model of ollamaModels) {
@@ -99,8 +135,8 @@ export class ModelRouter {
         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"}`);
+        log.info(`Available models: ${this.models.map((m) => m.name).join(", ") || "none"}`);
+        log.info(`Default model: ${this.defaultModel || "none"}`);
     }
     /**
      * Select the best model for a task based on its modelHint.
@@ -120,7 +156,7 @@ export class ModelRouter {
         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}"`);
+        log.info(`No model matches hint "${modelHint}", using default "${this.defaultModel}"`);
         return this.getByName(this.defaultModel);
     }
     getByName(name) {
@@ -129,7 +165,7 @@ export class ModelRouter {
             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}"`);
+            log.info(`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.");

package/dist/models/gemini-api.d.ts

@@ -0,0 +1,24 @@
+/**
+ * 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 { type SandboxConfig } from "../sandbox.js";
+import type { ExecutionResult } from "./claude.js";
+export declare class GeminiAPIAdapter {
+    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>;
+}