@epic-cloudcontrol/daemon 0.2.0

package/dist/config.js

@@ -0,0 +1,38 @@
+import os from "os";
+import { loadProfile } from "./profile.js";
+export function loadConfig(overrides = {}) {
+    const profileName = overrides.profileName;
+    const profile = loadProfile(profileName);
+    return {
+        apiUrl: overrides.apiUrl ||
+            process.env.CLOUDCONTROL_API_URL ||
+            profile?.apiUrl ||
+            "http://localhost:3000",
+        apiKey: overrides.apiKey ||
+            process.env.CLOUDCONTROL_API_KEY ||
+            profile?.apiKey ||
+            "",
+        workerName: overrides.workerName ||
+            process.env.CLOUDCONTROL_WORKER_NAME ||
+            profile?.workerName ||
+            `worker-${os.hostname()}`,
+        workerType: overrides.workerType ||
+            process.env.CLOUDCONTROL_WORKER_TYPE ||
+            "daemon",
+        capabilities: overrides.capabilities ||
+            (process.env.CLOUDCONTROL_CAPABILITIES?.split(",") ?? [
+                "browser",
+                "filesystem",
+                "shell",
+                "ai_execution",
+            ]),
+        taskTypeFilter: overrides.taskTypeFilter ||
+            (process.env.CLOUDCONTROL_TASK_TYPES?.split(",") ?? undefined),
+        pollInterval: overrides.pollInterval ||
+            parseInt(process.env.CLOUDCONTROL_POLL_INTERVAL || "15000"),
+        heartbeatInterval: overrides.heartbeatInterval || 30_000,
+        model: overrides.model || process.env.CLOUDCONTROL_MODEL,
+        profileName,
+    };
+}
+//# sourceMappingURL=config.js.map

package/dist/mcp-server.d.ts

@@ -0,0 +1,26 @@
+#!/usr/bin/env node
+/**
+ * CloudControl MCP Server
+ *
+ * 5 consolidated tools for Claude Desktop:
+ *   cloudcontrol        — account: whoami, profiles, switch company
+ *   cloudcontrol_tasks  — list, get, create tasks
+ *   cloudcontrol_work   — claim, submit, add process note
+ *   cloudcontrol_team   — list workers, post activity
+ *   cloudcontrol_search — search task history by type/title
+ *
+ * Usage in claude_desktop_config.json:
+ * {
+ *   "mcpServers": {
+ *     "cloudcontrol": {
+ *       "command": "npx",
+ *       "args": ["tsx", "/path/to/daemon/src/mcp-server.ts"],
+ *       "env": {
+ *         "CLOUDCONTROL_API_KEY": "cc_xxx",
+ *         "CLOUDCONTROL_API_URL": "https://cloudcontrol.onrender.com"
+ *       }
+ *     }
+ *   }
+ * }
+ */
+export {};

package/dist/mcp-server.js

@@ -0,0 +1,522 @@
+#!/usr/bin/env node
+/**
+ * CloudControl MCP Server
+ *
+ * 5 consolidated tools for Claude Desktop:
+ *   cloudcontrol        — account: whoami, profiles, switch company
+ *   cloudcontrol_tasks  — list, get, create tasks
+ *   cloudcontrol_work   — claim, submit, add process note
+ *   cloudcontrol_team   — list workers, post activity
+ *   cloudcontrol_search — search task history by type/title
+ *
+ * Usage in claude_desktop_config.json:
+ * {
+ *   "mcpServers": {
+ *     "cloudcontrol": {
+ *       "command": "npx",
+ *       "args": ["tsx", "/path/to/daemon/src/mcp-server.ts"],
+ *       "env": {
+ *         "CLOUDCONTROL_API_KEY": "cc_xxx",
+ *         "CLOUDCONTROL_API_URL": "https://cloudcontrol.onrender.com"
+ *       }
+ *     }
+ *   }
+ * }
+ */
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z } from "zod";
+import os from "os";
+import { DAEMON_VERSION } from "./version.js";
+import { loadProfile, listProfiles } from "./profile.js";
+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";
+let API_KEY = process.env.CLOUDCONTROL_API_KEY || profile?.apiKey || "";
+let WORKER_NAME = process.env.CLOUDCONTROL_WORKER_NAME || profile?.workerName || `${os.hostname()}-mcp`;
+let activeProfileName = profileName || "default";
+if (!API_KEY) {
+    console.error("CLOUDCONTROL_API_KEY or CLOUDCONTROL_PROFILE required");
+    process.exit(1);
+}
+let workerId = null;
+// ── Helpers ─────────────────────────────────────────
+async function apiCall(method, path, body) {
+    const res = await fetch(`${API_URL}${path}`, {
+        method,
+        headers: { authorization: `Bearer ${API_KEY}`, "content-type": "application/json" },
+        body: body ? JSON.stringify(body) : undefined,
+    });
+    const data = await res.json();
+    if (!res.ok)
+        throw new Error(`API ${res.status}: ${JSON.stringify(data)}`);
+    return data;
+}
+async function registerWorker() {
+    const data = await apiCall("POST", "/api/workers", {
+        name: WORKER_NAME,
+        workerType: "browser",
+        connectionMode: "manual",
+        platform: os.platform(),
+        capabilities: ["ai_execution", "code", "research"],
+        metadata: { arch: os.arch(), daemonVersion: DAEMON_VERSION, client: process.env.MCP_CLIENT_NAME || "claude-desktop", connectionType: "mcp" },
+    });
+    return data.worker.id;
+}
+async function sendHeartbeat() {
+    if (!workerId)
+        return;
+    try {
+        await apiCall("POST", "/api/workers/heartbeat", { workerId, status: "online" });
+    }
+    catch { }
+}
+let cachedPendingCount = 0;
+let lastPendingCheck = 0;
+async function getPendingCount() {
+    if (Date.now() - lastPendingCheck < 10_000)
+        return cachedPendingCount;
+    try {
+        const p = workerId ? `status=pending&limit=100&workerId=${workerId}` : "status=pending&limit=100";
+        const d = await apiCall("GET", `/api/tasks?${p}`);
+        cachedPendingCount = d.tasks.length;
+        lastPendingCheck = Date.now();
+    }
+    catch { }
+    return cachedPendingCount;
+}
+function withPending(text, count) {
+    return count > 0 ? `${text}\n\n---\n📋 ${count} pending task${count !== 1 ? "s" : ""} available.` : text;
+}
+async function resolveProcess(taskType) {
+    try {
+        const d = await apiCall("GET", `/api/processes/resolve?taskType=${encodeURIComponent(taskType)}`);
+        if (!d.parsed?.steps?.length)
+            return null;
+        const lines = [`\n## Process: ${d.parsed.name} v${d.parsed.version}\n`];
+        for (let i = 0; i < d.parsed.steps.length; i++) {
+            const s = d.parsed.steps[i];
+            let desc = `${i + 1}. [${s.type}] ${s.id}`;
+            if (s.prompt)
+                desc += ` — ${s.prompt}`;
+            if (s.gate === "approval_required")
+                desc += ` ⚠️ REQUIRES APPROVAL`;
+            lines.push(desc);
+        }
+        return lines.join("\n");
+    }
+    catch {
+        return null;
+    }
+}
+function ok(text) { return { content: [{ type: "text", text }] }; }
+/**
+ * Discover and save profiles for all teams accessible via the current API key.
+ * Uses GET /api/auth/teams with Bearer token — no email/password needed.
+ * Returns a list of lines describing what was found/saved.
+ */
+async function refreshProfiles() {
+    const { saveProfile: save } = await import("./profile.js");
+    const lines = [];
+    try {
+        const res = await fetch(`${API_URL}/api/auth/teams?generateKeys=true`, {
+            headers: { authorization: `Bearer ${API_KEY}` },
+        });
+        if (!res.ok) {
+            const err = await res.json().catch(() => ({}));
+            lines.push(`Refresh failed: ${err.error || res.status}`);
+            return lines;
+        }
+        const data = await res.json();
+        const existing = new Set(listProfiles().map((p) => p.name));
+        let newCount = 0;
+        for (const team of data.teams) {
+            const slug = team.teamName.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+            if (!existing.has(slug) && team.apiKey) {
+                save({ apiUrl: API_URL, apiKey: team.apiKey, workerName: WORKER_NAME, teamName: team.teamName }, slug);
+                lines.push(`✓ New: ${team.teamName} → profile "${slug}"`);
+                newCount++;
+            }
+            else {
+                lines.push(`  ${team.teamName} → already synced`);
+            }
+        }
+        if (newCount === 0) {
+            lines.unshift(`All ${data.teams.length} company(s) already synced.`);
+        }
+        else {
+            lines.unshift(`Found ${newCount} new company(s) (${data.teams.length} total):`);
+        }
+    }
+    catch (err) {
+        lines.push(`Refresh error: ${err.message}`);
+    }
+    return lines;
+}
+// ── MCP Server ──────────────────────────────────────
+const server = new McpServer({ name: "cloudcontrol", version: DAEMON_VERSION }, {
+    capabilities: { tools: {}, resources: {} },
+    instructions: "CloudControl task orchestration. Use cloudcontrol_tasks to list/create tasks, cloudcontrol_work to claim/submit, cloudcontrol to manage your account and company profiles.",
+});
+// ── Tool 1: cloudcontrol (account management) ───────
+server.tool("cloudcontrol", "Account & COO: whoami, profiles, switch company, refresh (discover new companies), sync (email login), or talk to the COO agent", {
+    action: z.enum(["whoami", "profiles", "switch", "refresh", "sync", "coo"]).describe("Action: whoami, profiles, switch, refresh (discover new companies without password), sync (email login), coo (talk to COO agent)"),
+    profile: z.string().optional().describe("Profile name (for switch)"),
+    email: z.string().optional().describe("Email (for sync)"),
+    password: z.string().optional().describe("Password (for sync)"),
+    message: z.string().optional().describe("Message to the COO (for coo action — ask questions, give directives, request reports)"),
+}, async ({ action, profile: targetProfile, email, password, message }) => {
+    if (action === "whoami") {
+        const pending = await getPendingCount();
+        return ok(withPending(JSON.stringify({ workerId, workerName: WORKER_NAME, activeProfile: activeProfileName, apiUrl: API_URL, platform: os.platform() }, null, 2), pending));
+    }
+    if (action === "profiles") {
+        const profiles = listProfiles();
+        if (profiles.length === 0)
+            return ok("No profiles saved. Run 'cloudcontrol login --profile <name>' in a terminal.");
+        const lines = profiles.map((p) => `${p.name === activeProfileName ? "→ " : "  "}${p.name}: ${p.profile.teamName || "—"} (${p.profile.apiUrl})`);
+        return ok(`Company profiles:\n\n${lines.join("\n")}\n\nUse action=switch, profile=<name> to change.`);
+    }
+    if (action === "switch") {
+        if (!targetProfile)
+            return ok("Provide profile name. Use action=profiles to see available.");
+        const loaded = loadProfile(targetProfile);
+        if (!loaded) {
+            const avail = listProfiles().map((p) => p.name).join(", ");
+            return ok(`Profile "${targetProfile}" not found. Available: ${avail || "none"}`);
+        }
+        API_URL = loaded.apiUrl;
+        API_KEY = loaded.apiKey;
+        WORKER_NAME = loaded.workerName || `${os.hostname()}-mcp`;
+        activeProfileName = targetProfile;
+        try {
+            workerId = await registerWorker();
+        }
+        catch { }
+        cachedPendingCount = 0;
+        lastPendingCheck = 0;
+        const pending = await getPendingCount();
+        return ok(withPending(`✅ Switched to "${loaded.teamName || targetProfile}"\nWorker: ${WORKER_NAME}\nWorker ID: ${workerId}`, pending));
+    }
+    if (action === "refresh") {
+        const lines = await refreshProfiles();
+        lines.push(``, `Use action=profiles to see all, action=switch to change.`);
+        return ok(lines.join("\n"));
+    }
+    if (action === "sync") {
+        if (!email || !password)
+            return ok("Provide email and password to sync all your companies.");
+        try {
+            const res = await fetch(`${API_URL}/api/auth/teams`, {
+                method: "POST",
+                headers: { "content-type": "application/json" },
+                body: JSON.stringify({ email, password, generateKeys: true }),
+            });
+            if (!res.ok) {
+                const err = await res.json();
+                return ok(`Sync failed: ${err.error || res.status}`);
+            }
+            const data = await res.json();
+            const { saveProfile: save } = await import("./profile.js");
+            const lines = [`Synced ${data.teams.length} company(s):\n`];
+            for (const team of data.teams) {
+                const slug = team.teamName.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+                save({ apiUrl: API_URL, apiKey: team.apiKey, workerName: WORKER_NAME, teamName: team.teamName }, slug);
+                lines.push(`✓ ${team.teamName} → profile "${slug}" (${team.role})`);
+            }
+            if (data.teams.length > 0) {
+                save({ apiUrl: API_URL, apiKey: data.teams[0].apiKey, workerName: WORKER_NAME, teamName: data.teams[0].teamName });
+            }
+            lines.push(`\nUse action=profiles to see all, action=switch to change.`);
+            return ok(lines.join("\n"));
+        }
+        catch (err) {
+            return ok(`Sync error: ${err.message}`);
+        }
+    }
+    if (action === "coo") {
+        if (!message)
+            return ok("Provide a message for the COO. Ask about operations, give directives, or request reports.");
+        // Send CEO message
+        await apiCall("POST", "/api/dashboard/coo", { action: "message", content: message });
+        // Fetch recent COO responses (may include response to this message if COO loop ran, otherwise latest context)
+        const data = await apiCall("GET", "/api/dashboard/coo");
+        const recent = data.messages.slice(-5);
+        const goalLines = data.goals.map((g) => {
+            const pct = g.target > 0 ? Math.round((g.current / g.target) * 100) : 0;
+            return `  ${pct >= 100 ? "✅" : pct >= 70 ? "🟡" : "🔴"} ${g.metric}: ${g.current}/${g.target} ${g.unit || ""} (${pct}%)`;
+        });
+        const lines = [`Message sent to COO.`, ``];
+        if (goalLines.length > 0) {
+            lines.push(`**Current Goals:**`, ...goalLines, ``);
+        }
+        if (recent.length > 0) {
+            lines.push(`**Recent conversation:**`);
+            for (const m of recent) {
+                lines.push(`${m.role === "ceo" ? "👤 CEO" : "🤖 COO"}: ${m.content.slice(0, 300)}`);
+            }
+        }
+        lines.push(``, `The COO will respond within ${5} minutes. Check back with action=coo (no message) to see the response.`);
+        return ok(lines.join("\n"));
+    }
+    return ok("Unknown action. Use: whoami, profiles, switch, sync, or coo.");
+});
+// ── Tool 2: cloudcontrol_tasks (list, get, create) ──
+server.tool("cloudcontrol_tasks", "Manage tasks: list tasks (filter by status/type), get full task details, or create a new task", {
+    action: z.enum(["list", "get", "create"]).describe("Action: list, get (by ID), or create"),
+    taskId: z.string().optional().describe("Task UUID (for action=get)"),
+    status: z.string().optional().describe("Filter by status: pending, claimed, running, completed, failed, human_required (for action=list)"),
+    taskType: z.string().optional().describe("Filter by task type (for action=list) or set type (for action=create)"),
+    limit: z.number().optional().describe("Max results for list (default 20)"),
+    title: z.string().optional().describe("Task title (for action=create)"),
+    description: z.string().optional().describe("Task description (for action=create)"),
+    priority: z.enum(["low", "normal", "high", "urgent"]).optional().describe("Priority (for action=create)"),
+    modelHint: z.string().optional().describe("AI model hint (for action=create)"),
+    workspace: z.string().optional().describe("Workspace slug (for action=create)"),
+    successCriteria: z.string().optional().describe("What does done look like (for action=create)"),
+    context: z.string().optional().describe("JSON context (for action=create)"),
+}, async ({ action, taskId, status, taskType, limit, title, description, priority, modelHint, workspace, successCriteria, context: ctxStr }) => {
+    if (action === "list") {
+        const params = new URLSearchParams();
+        if (status)
+            params.set("status", status);
+        if (limit)
+            params.set("limit", String(limit));
+        else
+            params.set("limit", "20");
+        if (workerId)
+            params.set("workerId", workerId);
+        const d = await apiCall("GET", `/api/tasks?${params}`);
+        let tasks = d.tasks;
+        if (taskType)
+            tasks = tasks.filter((t) => t.taskType === taskType);
+        return ok(JSON.stringify(tasks.map((t) => ({ id: t.id, title: t.title, status: t.status, taskType: t.taskType, priority: t.priority, modelHint: t.modelHint, workspace: t.workspace, description: typeof t.description === "string" ? t.description?.slice(0, 200) : null })), null, 2));
+    }
+    if (action === "get") {
+        if (!taskId)
+            return ok("Provide taskId.");
+        const d = await apiCall("GET", `/api/tasks/${taskId}`);
+        return ok(JSON.stringify(d.task, null, 2));
+    }
+    if (action === "create") {
+        if (!title)
+            return ok("Provide title.");
+        let context;
+        if (ctxStr) {
+            try {
+                context = JSON.parse(ctxStr);
+            }
+            catch {
+                context = { raw: ctxStr };
+            }
+        }
+        const d = await apiCall("POST", "/api/tasks", { title, description, taskType, priority: priority || "normal", modelHint, workspace, successCriteria, context, delegatedBy: workerId });
+        const pending = await getPendingCount();
+        return ok(withPending(`Task created: ${d.task.title} (${d.task.id})`, pending));
+    }
+    return ok("Unknown action. Use: list, get, or create.");
+});
+// ── Tool 3: cloudcontrol_work (claim, submit, note) ─
+server.tool("cloudcontrol_work", "Execute tasks: claim a task (get full context + process steps), submit results, or add a process improvement note", {
+    action: z.enum(["claim", "submit", "note"]).describe("Action: claim (reserve task), submit (complete task), note (add process note)"),
+    taskId: z.string().describe("Task UUID"),
+    status: z.enum(["completed", "failed", "human_required"]).optional().describe("Outcome status (for action=submit)"),
+    result: z.string().optional().describe("Result text or JSON (for action=submit)"),
+    dialogue: z.string().optional().describe("Your reasoning and approach (for action=submit)"),
+    processNote: z.string().optional().describe("Advice for future workers (for action=submit or action=note)"),
+    humanContext: z.string().optional().describe("Why human needed (for action=submit with status=human_required)"),
+}, async ({ action, taskId, status, result, dialogue, processNote, humanContext }) => {
+    if (!workerId)
+        return ok("Worker not registered. Restart the MCP server.");
+    if (action === "claim") {
+        const d = await apiCall("POST", `/api/tasks/${taskId}/claim`, { workerId });
+        const task = d.task;
+        const lines = [
+            `✅ Task claimed.`,
+            ``,
+            `**${task.title}**`,
+            `ID: ${task.id} | Type: ${task.taskType || "general"} | Priority: ${task.priority}`,
+        ];
+        if (task.description)
+            lines.push(``, `## Description`, String(task.description));
+        if (task.context)
+            lines.push(``, `## Context`, `\`\`\`json`, JSON.stringify(task.context, null, 2), `\`\`\``);
+        if (task.humanContext)
+            lines.push(``, `## Previous Feedback`, String(task.humanContext));
+        if (task.processHint)
+            lines.push(``, `## Process Hint`, String(task.processHint));
+        // Workspace context
+        if (task.workspace) {
+            try {
+                const ws = await apiCall("GET", `/api/workspaces?slug=${encodeURIComponent(String(task.workspace))}`);
+                if (ws.found && ws.workspace) {
+                    lines.push(``, `## Workspace: ${ws.workspace.name}`);
+                    if (ws.workspace.description)
+                        lines.push(ws.workspace.description);
+                    if (ws.workspace.context)
+                        lines.push(``, `### Context`, ws.workspace.context);
+                }
+            }
+            catch { }
+        }
+        // Process steps + history
+        if (task.taskType) {
+            const proc = await resolveProcess(String(task.taskType));
+            if (proc)
+                lines.push(proc);
+            try {
+                const hp = new URLSearchParams();
+                hp.set("taskType", String(task.taskType));
+                if (task.title)
+                    hp.set("title", String(task.title));
+                const h = await apiCall("GET", `/api/tasks/history?${hp}`);
+                if (h.found && h.lastCompleted) {
+                    lines.push(``, `## Prior Run`);
+                    lines.push(`Last: "${h.lastCompleted.title}" ${h.matchCount && h.matchCount > 1 ? `(${h.matchCount} runs found)` : ""}`);
+                    if (h.lastCompleted.resultSummary)
+                        lines.push(`Result: ${h.lastCompleted.resultSummary.slice(0, 300)}`);
+                    if (h.processNotes?.length) {
+                        lines.push(``, `### Process Notes`);
+                        for (const n of h.processNotes)
+                            lines.push(n);
+                    }
+                }
+            }
+            catch { }
+        }
+        if (task.successCriteria)
+            lines.push(``, `## Success Criteria`, String(task.successCriteria));
+        else
+            lines.push(``, `⚠️ No success criteria defined.`);
+        // Dependencies
+        if (task.parentTaskId) {
+            try {
+                const p = await apiCall("GET", `/api/tasks/${task.parentTaskId}`);
+                lines.push(``, `## Parent: "${p.task.title}" (${p.task.status})`);
+            }
+            catch { }
+        }
+        try {
+            const ch = await apiCall("GET", `/api/tasks?parentTaskId=${task.id}&limit=20`);
+            if (ch.tasks.length > 0) {
+                lines.push(``, `## Sub-tasks (${ch.tasks.length})`);
+                for (const c of ch.tasks)
+                    lines.push(`${c.status === "completed" ? "✅" : c.status === "failed" ? "❌" : "⏳"} ${c.title} (${c.status})`);
+            }
+        }
+        catch { }
+        lines.push(``, `---`, `When done, use cloudcontrol_work action=submit.`);
+        const pending = await getPendingCount();
+        return ok(withPending(lines.join("\n"), pending));
+    }
+    if (action === "submit") {
+        if (!status)
+            return ok("Provide status: completed, failed, or human_required.");
+        let resultObj = {};
+        if (result) {
+            try {
+                resultObj = JSON.parse(result);
+            }
+            catch {
+                resultObj = { output: result };
+            }
+        }
+        const dialogueArr = dialogue ? [{ role: "assistant", content: dialogue, timestamp: new Date().toISOString() }] : undefined;
+        const d = await apiCall("POST", `/api/tasks/${taskId}/submit`, { workerId, status, result: resultObj, dialogue: dialogueArr, humanContext, metadata: { source: "mcp" } });
+        if (processNote) {
+            try {
+                await apiCall("POST", `/api/tasks/${taskId}/activity`, { activityType: "comment", content: `📝 Process note for "${d.task.taskType || "general"}" tasks:\n${processNote}`, workerId, metadata: { type: "process_note" } });
+            }
+            catch { }
+        }
+        const pending = await getPendingCount();
+        const lines = [`Task submitted as ${status}. ${JSON.stringify({ id: d.task.id, title: d.task.title }, null, 2)}`];
+        if (processNote)
+            lines.push(`\n✅ Process note saved.`);
+        else
+            lines.push(`\n💡 Add a process note? Use action=note to help future workers.`);
+        return ok(withPending(lines.join(""), pending));
+    }
+    if (action === "note") {
+        if (!processNote)
+            return ok("Provide processNote with your advice for future workers.");
+        const td = await apiCall("GET", `/api/tasks/${taskId}`);
+        await apiCall("POST", `/api/tasks/${taskId}/activity`, { activityType: "comment", content: `📝 Process note for "${td.task.taskType || "general"}" tasks:\n${processNote}`, workerId, metadata: { type: "process_note" } });
+        return ok(`✅ Process note saved for "${td.task.taskType || "general"}" tasks.`);
+    }
+    return ok("Unknown action. Use: claim, submit, or note.");
+});
+// ── Tool 4: cloudcontrol_team (workers, activity) ───
+server.tool("cloudcontrol_team", "Team management: list workers or post a progress update on a task", {
+    action: z.enum(["workers", "activity"]).describe("Action: workers (list team), activity (post update on task)"),
+    taskId: z.string().optional().describe("Task UUID (for action=activity)"),
+    content: z.string().optional().describe("Progress update text (for action=activity)"),
+}, async ({ action, taskId, content: activityContent }) => {
+    if (action === "workers") {
+        const d = await apiCall("GET", "/api/workers");
+        return ok(JSON.stringify(d.workers.map((w) => ({
+            id: w.id, name: w.name, workerType: w.workerType, status: w.status,
+            capabilities: w.capabilities, isYou: w.id === workerId,
+        })), null, 2));
+    }
+    if (action === "activity") {
+        if (!taskId || !activityContent)
+            return ok("Provide taskId and content.");
+        await apiCall("POST", `/api/tasks/${taskId}/activity`, { activityType: "progress", content: activityContent, workerId });
+        const pending = await getPendingCount();
+        return ok(withPending(`Activity posted on task ${taskId}.`, pending));
+    }
+    return ok("Unknown action. Use: workers or activity.");
+});
+// ── Tool 5: cloudcontrol_search (task history) ──────
+server.tool("cloudcontrol_search", "Search task history: find prior completed runs by task type or title for institutional memory", {
+    taskType: z.string().optional().describe("Task type to search (e.g., research, test.e2e, directory_submission)"),
+    title: z.string().optional().describe("Task title keywords for similarity matching"),
+}, async ({ taskType, title }) => {
+    if (!taskType && !title)
+        return ok("Provide taskType or title to search.");
+    const params = new URLSearchParams();
+    if (taskType)
+        params.set("taskType", taskType);
+    if (title)
+        params.set("title", title);
+    const d = await apiCall("GET", `/api/tasks/history?${params}`);
+    return ok(JSON.stringify(d, null, 2));
+});
+// ── Resources ───────────────────────────────────────
+server.resource("cloudcontrol://tasks/pending", "cloudcontrol://tasks/pending", async () => {
+    const p = workerId ? `status=pending&limit=20&workerId=${workerId}` : "status=pending&limit=20";
+    const d = await apiCall("GET", `/api/tasks?${p}`);
+    return { contents: [{ uri: "cloudcontrol://tasks/pending", mimeType: "application/json", text: JSON.stringify(d.tasks, null, 2) }] };
+});
+server.resource("cloudcontrol://health", "cloudcontrol://health", async () => {
+    const res = await fetch(`${API_URL}/api/health`);
+    const d = await res.json();
+    return { contents: [{ uri: "cloudcontrol://health", mimeType: "application/json", text: JSON.stringify(d, null, 2) }] };
+});
+// ── Start ───────────────────────────────────────────
+async function main() {
+    try {
+        workerId = await registerWorker();
+        console.error(`[mcp] Registered as worker ${workerId} (${WORKER_NAME})`);
+    }
+    catch (err) {
+        console.error(`[mcp] 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)`);
+            for (const l of newLines)
+                console.error(`[mcp]   ${l}`);
+        }
+    }).catch(() => { });
+    const heartbeatTimer = setInterval(sendHeartbeat, 30_000);
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    console.error("[mcp] CloudControl MCP server running");
+    process.on("SIGINT", () => { clearInterval(heartbeatTimer); process.exit(0); });
+}
+main().catch((err) => { console.error("[mcp] Fatal:", err); process.exit(1); });
+//# sourceMappingURL=mcp-server.js.map

package/dist/model-router.d.ts

@@ -0,0 +1,40 @@
+import { type ExecutionResult } from "./models/claude.js";
+export interface ModelAdapter {
+    execute(task: TaskInput): Promise<ExecutionResult>;
+}
+export interface TaskInput {
+    title: string;
+    description?: string | null;
+    taskType?: string | null;
+    context?: Record<string, unknown> | null;
+    processHint?: string | null;
+    humanContext?: string | null;
+}
+/**
+ * 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 declare class ModelRouter {
+    private models;
+    private defaultModel;
+    constructor();
+    private detectAvailableModels;
+    /**
+     * Select the best model for a task based on its modelHint.
+     */
+    select(modelHint?: string | null): {
+        adapter: ModelAdapter;
+        name: string;
+    };
+    private getByName;
+    getDefault(): string;
+    listModels(): Array<{
+        name: string;
+        traits: string[];
+    }>;
+}