@epic-cloudcontrol/daemon 0.2.0

package/README.md

@@ -0,0 +1,150 @@
+# @epic-cloudcontrol/daemon
+
+Local daemon for [CloudControl](https://github.com/Epic-Design-Labs/app-cloudcontrol) — connects your machine to the cloud control plane. AI agents and humans pull tasks, execute them locally, and report results.
+
+## Install
+
+```bash
+npm install -g @epic-cloudcontrol/daemon
+```
+
+## Quick Start
+
+```bash
+# 1. Log in (syncs all your companies)
+cloudcontrol login --email you@example.com
+
+# 2. Install as auto-start service (starts on boot)
+cloudcontrol install
+
+# 3. Verify
+cloudcontrol status
+```
+
+Done. The daemon runs in the background, polls all your companies for tasks, and executes them via AI.
+
+## Commands
+
+| Command | Description |
+|---------|-------------|
+| `cloudcontrol login` | Log in with email, sync all company profiles |
+| `cloudcontrol profiles` | List saved company profiles |
+| `cloudcontrol refresh` | Discover new companies (no password needed) |
+| `cloudcontrol models` | List available AI models on this machine |
+| `cloudcontrol status` | Show config, connection status, service status |
+| `cloudcontrol start` | Start daemon for one profile (foreground) |
+| `cloudcontrol start --all` | Start daemon for ALL profiles (foreground) |
+| `cloudcontrol install` | Install as system service (auto-start on boot) |
+| `cloudcontrol uninstall` | Remove system service |
+| `cloudcontrol logs` | View daemon logs (`--follow`, `--errors`, `-n 100`) |
+| `cloudcontrol mcp` | Start MCP server for Claude Desktop |
+
+## Claude Desktop Integration
+
+Add to `~/Library/Application Support/Claude/claude_desktop_config.json` (macOS) or equivalent:
+
+```json
+{
+  "mcpServers": {
+    "cloudcontrol": {
+      "command": "cloudcontrol",
+      "args": ["mcp"]
+    }
+  }
+}
+```
+
+For a specific company:
+
+```json
+{
+  "mcpServers": {
+    "cloudcontrol": {
+      "command": "cloudcontrol",
+      "args": ["mcp", "--profile", "my-company"]
+    }
+  }
+}
+```
+
+## Multi-Company
+
+The daemon supports multiple companies from one machine:
+
+```bash
+# Login syncs all companies you belong to
+cloudcontrol login --email you@example.com
+
+# See them
+cloudcontrol profiles
+
+# Run all at once
+cloudcontrol start --all
+
+# Or pick one
+cloudcontrol start --profile my-company
+```
+
+When installed as a service (`cloudcontrol install`), it runs `--all` automatically.
+
+New companies added in the dashboard are auto-discovered on daemon restart, or manually via:
+
+```bash
+cloudcontrol refresh
+```
+
+## AI Models
+
+The daemon auto-detects available AI models:
+
+| Source | Models | Setup |
+|--------|--------|-------|
+| Claude API | claude-sonnet, claude-haiku | `export ANTHROPIC_API_KEY=sk-ant-...` |
+| Claude Code | claude-code | Install: `npm i -g @anthropic-ai/claude-code` |
+| Gemini | gemini | Install: `npm i -g @google/gemini-cli` |
+| Ollama | llama3, mistral, etc. | `export CLOUDCONTROL_OLLAMA_MODELS=llama3,mistral` |
+| Custom CLI | any | `export CLOUDCONTROL_CLI_MODELS="name:binary:args"` |
+
+Check what's available:
+
+```bash
+cloudcontrol models
+```
+
+## Auto-Start Details
+
+`cloudcontrol install` creates a platform-specific service:
+
+| Platform | Mechanism | Config Location |
+|----------|-----------|----------------|
+| macOS | LaunchAgent | `~/Library/LaunchAgents/com.cloudcontrol.daemon.plist` |
+| Linux | systemd user service | `~/.config/systemd/user/cloudcontrol-daemon.service` |
+| Windows | Scheduled Task | Task: `CloudControlDaemon` |
+
+Logs are written to `~/.cloudcontrol/logs/`. View with:
+
+```bash
+cloudcontrol logs          # stdout
+cloudcontrol logs --errors # stderr
+cloudcontrol logs --follow # tail -f
+```
+
+## Configuration
+
+All config is stored in `~/.cloudcontrol/`:
+
+```
+~/.cloudcontrol/
+├── config.json              # default profile
+├── profiles/
+│   ├── my-company.json      # named profile
+│   └── other-company.json
+└── logs/
+    ├── daemon.log
+    └── daemon.err
+```
+
+## Requirements
+
+- Node.js 20+
+- A CloudControl account (self-hosted or cloud)

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli.js

@@ -0,0 +1,525 @@
+#!/usr/bin/env node
+import { config } from "dotenv";
+import path from "path";
+import { fileURLToPath } from "url";
+// Load .env.local from project root (for local dev)
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+config({ path: path.resolve(__dirname, "../../.env.local") });
+import { Command } from "commander";
+import os from "os";
+import readline from "readline";
+import { execSync } from "child_process";
+import { existsSync } from "fs";
+import { loadConfig } from "./config.js";
+import { loadProfile, saveProfile, profileExists, listProfiles, getConfigDir } from "./profile.js";
+import { TaskExecutor } from "./task-executor.js";
+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";
+const program = new Command();
+program
+    .name("cloudcontrol")
+    .description("CloudControl workstation daemon — connects your machine to the cloud control plane")
+    .version(DAEMON_VERSION);
+// ── login ─────────────────────────────────────────────
+program
+    .command("login")
+    .description("Log in and sync all your company profiles")
+    .option("--email <email>", "Log in with email (syncs all companies automatically)")
+    .option("--profile <name>", "Profile name for single-key setup", "default")
+    .option("--api-url <url>", "CloudControl API URL")
+    .option("--api-key <key>", "API key (for single-company manual setup)")
+    .option("--name <name>", "Worker name")
+    .action(async (opts) => {
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    const ask = (q, defaultVal) => new Promise((resolve) => {
+        const prompt = defaultVal ? `${q} [${defaultVal}]: ` : `${q}: `;
+        rl.question(prompt, (answer) => resolve(answer.trim() || defaultVal || ""));
+    });
+    let apiUrl = opts.apiUrl;
+    if (!apiUrl) {
+        const existing = loadProfile();
+        apiUrl = await ask("CloudControl API URL", existing?.apiUrl || "https://cloudcontrol.onrender.com");
+    }
+    // Email login mode — sync all companies
+    const email = opts.email || await ask("Email (or leave blank for API key setup)");
+    if (email) {
+        const password = await ask("Password");
+        rl.close();
+        if (!password) {
+            console.error("Error: Password required.");
+            process.exit(1);
+        }
+        console.log("\nAuthenticating...");
+        try {
+            const res = await fetch(`${apiUrl}/api/auth/teams`, {
+                method: "POST",
+                headers: { "content-type": "application/json" },
+                body: JSON.stringify({ email, password, generateKeys: true }),
+            });
+            if (!res.ok) {
+                const data = await res.json();
+                console.error(`Login failed: ${data.error || res.status}`);
+                process.exit(1);
+            }
+            const data = await res.json();
+            const workerName = opts.name || `worker-${os.hostname()}`;
+            console.log(`\nLogged in as ${data.user.email}`);
+            console.log(`Found ${data.teams.length} company(s):\n`);
+            for (const team of data.teams) {
+                // Generate slug from team name
+                const slug = team.teamName
+                    .toLowerCase()
+                    .replace(/[^a-z0-9]+/g, "-")
+                    .replace(/^-|-$/g, "");
+                saveProfile({
+                    apiUrl,
+                    apiKey: team.apiKey,
+                    workerName,
+                    teamName: team.teamName,
+                }, slug);
+                console.log(`  ✓ ${team.teamName} → profile "${slug}" (${team.role})`);
+            }
+            // Also save the first team as default
+            if (data.teams.length > 0) {
+                const first = data.teams[0];
+                saveProfile({
+                    apiUrl,
+                    apiKey: first.apiKey,
+                    workerName,
+                    teamName: first.teamName,
+                });
+            }
+            console.log(`\n${data.teams.length} profile(s) saved to ${getConfigDir()}/`);
+            console.log("Run 'cloudcontrol profiles' to see them.");
+            console.log("Run 'cloudcontrol start --profile <name>' to start working.");
+        }
+        catch (err) {
+            console.error(`Error: ${err.message}`);
+            process.exit(1);
+        }
+    }
+    else {
+        // Manual API key mode (original flow)
+        const profileName = opts.profile;
+        let apiKey = opts.apiKey;
+        let workerName = opts.name;
+        let teamName;
+        const existing = loadProfile(profileName);
+        if (!teamName)
+            teamName = await ask("Company name", existing?.teamName || profileName);
+        if (!apiKey)
+            apiKey = await ask("API Key (cc_...)", existing?.apiKey);
+        if (!workerName)
+            workerName = await ask("Worker name", existing?.workerName || `worker-${os.hostname()}`);
+        rl.close();
+        if (!apiKey) {
+            console.error("Error: API key is required.");
+            process.exit(1);
+        }
+        console.log("\nVerifying connection...");
+        try {
+            const res = await fetch(`${apiUrl}/api/health`);
+            if (!res.ok)
+                throw new Error(`HTTP ${res.status}`);
+            console.log("Connected to CloudControl.");
+        }
+        catch (err) {
+            console.error(`Warning: Could not reach ${apiUrl} — ${err.message}`);
+        }
+        saveProfile({ apiUrl, apiKey, workerName, teamName }, profileName);
+        console.log(`\nProfile "${profileName}" saved to ${getConfigDir()}/`);
+        console.log("Run 'cloudcontrol start' to begin processing tasks.");
+    }
+});
+// ── profiles ──────────────────────────────────────────
+program
+    .command("profiles")
+    .description("List all saved company profiles")
+    .action(() => {
+    const profiles = listProfiles();
+    if (profiles.length === 0) {
+        console.log("No profiles saved. Run 'cloudcontrol login' to create one.");
+        return;
+    }
+    console.log("\nSaved profiles:\n");
+    console.log("  Name                Company              API URL");
+    console.log("  ──────────────────  ───────────────────  ──────────────────────────");
+    for (const { name, profile } of profiles) {
+        const teamName = profile.teamName || "—";
+        console.log(`  ${name.padEnd(20)}${teamName.padEnd(21)}${profile.apiUrl}`);
+    }
+    console.log("");
+    console.log("Use: cloudcontrol start --profile <name>");
+});
+// ── refresh ──────────────────────────────────────────
+program
+    .command("refresh")
+    .description("Discover new companies using your existing API key (no password needed)")
+    .option("--profile <name>", "Profile to use as the source key", "default")
+    .action(async (opts) => {
+    const profile = loadProfile(opts.profile);
+    if (!profile?.apiKey) {
+        console.error("Error: No API key found. Run 'cloudcontrol login' first.");
+        process.exit(1);
+    }
+    console.log("Checking for new companies...\n");
+    try {
+        const res = await fetch(`${profile.apiUrl}/api/auth/teams?generateKeys=true`, {
+            headers: { authorization: `Bearer ${profile.apiKey}` },
+        });
+        if (!res.ok) {
+            const data = await res.json().catch(() => ({}));
+            console.error(`Failed: ${data.error || res.status}`);
+            process.exit(1);
+        }
+        const data = await res.json();
+        const existing = new Set(listProfiles().map((p) => p.name));
+        const workerName = profile.workerName || `worker-${os.hostname()}`;
+        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) {
+                saveProfile({
+                    apiUrl: profile.apiUrl,
+                    apiKey: team.apiKey,
+                    workerName,
+                    teamName: team.teamName,
+                }, slug);
+                console.log(`  ✓ New: ${team.teamName} → profile "${slug}" (${team.role})`);
+                newCount++;
+            }
+            else {
+                console.log(`    ${team.teamName} → already synced`);
+            }
+        }
+        if (newCount > 0) {
+            console.log(`\n${newCount} new company(s) added.`);
+        }
+        else {
+            console.log(`\nAll ${data.teams.length} company(s) already synced.`);
+        }
+        console.log("Run 'cloudcontrol profiles' to see them.");
+    }
+    catch (err) {
+        console.error(`Error: ${err.message}`);
+        process.exit(1);
+    }
+});
+// ── install ──────────────────────────────────────────
+program
+    .command("install")
+    .description("Install daemon as a system service (auto-starts on login)")
+    .action(() => {
+    const platform = detectPlatform();
+    console.log(`\nPlatform: ${platform}`);
+    console.log("Installing CloudControl daemon as a background service...\n");
+    const profiles = listProfiles();
+    if (profiles.length === 0) {
+        console.error("Error: No profiles found. Run 'cloudcontrol login' first.");
+        process.exit(1);
+    }
+    console.log(`Will run ${profiles.length} company(s):`);
+    for (const { name, profile } of profiles) {
+        console.log(`  - ${profile.teamName || name}`);
+    }
+    console.log("");
+    const result = install();
+    if (result.success) {
+        console.log(`Done! ${result.message}`);
+    }
+    else {
+        console.error(`Error: ${result.message}`);
+        process.exit(1);
+    }
+});
+// ── uninstall ────────────────────────────────────────
+program
+    .command("uninstall")
+    .description("Remove daemon system service (stops auto-start)")
+    .action(() => {
+    const result = uninstall();
+    console.log(result.message);
+    if (!result.success)
+        process.exit(1);
+});
+// ── logs ─────────────────────────────────────────────
+program
+    .command("logs")
+    .description("Show daemon service logs")
+    .option("--errors", "Show error log instead of stdout")
+    .option("--follow", "Follow log output (tail -f)")
+    .option("-n, --lines <count>", "Number of lines to show", "50")
+    .action((opts) => {
+    const logPath = opts.errors ? getErrorLogPath() : getLogPath();
+    const platform = detectPlatform();
+    // Linux: prefer journalctl
+    if (platform === "linux" && !opts.errors) {
+        try {
+            const args = opts.follow ? "-f" : `-n ${opts.lines}`;
+            execSync(`journalctl --user -u cloudcontrol-daemon ${args}`, { stdio: "inherit" });
+            return;
+        }
+        catch { /* fallback to file */ }
+    }
+    if (!existsSync(logPath)) {
+        console.log(`No log file at ${logPath}`);
+        console.log("The daemon may not have been installed yet. Run 'cloudcontrol install'.");
+        return;
+    }
+    const cmd = opts.follow ? `tail -f "${logPath}"` : `tail -n ${opts.lines} "${logPath}"`;
+    try {
+        execSync(cmd, { stdio: "inherit" });
+    }
+    catch {
+        console.error(`Could not read log file: ${logPath}`);
+    }
+});
+// ── models ────────────────────────────────────────────
+program
+    .command("models")
+    .description("List available AI models on this machine")
+    .option("--profile <name>", "Profile to use", "default")
+    .action((opts) => {
+    const router = new ModelRouter();
+    const models = router.listModels();
+    if (models.length === 0) {
+        console.log("No models available.");
+        console.log("Install a CLI (claude, gemini, codex), set ANTHROPIC_API_KEY, or configure Ollama.");
+        return;
+    }
+    console.log("\nAvailable models:\n");
+    console.log("  Name                Traits");
+    console.log("  ──────────────────  ──────────────────────────");
+    for (const m of models) {
+        console.log(`  ${m.name.padEnd(20)}${m.traits.join(", ")}`);
+    }
+    console.log("");
+    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("  Ollama:           export CLOUDCONTROL_OLLAMA_MODELS=llama3,mistral");
+    console.log("  Custom CLI:       export CLOUDCONTROL_CLI_MODELS=\"mycli:mybinary:-p\"");
+});
+// ── status ────────────────────────────────────────────
+program
+    .command("status")
+    .description("Check connection to CloudControl and show config")
+    .option("--profile <name>", "Profile to use", "default")
+    .action(async (opts) => {
+    const profile = loadProfile(opts.profile);
+    const cfg = loadConfig({ profileName: opts.profile });
+    console.log("\nConfiguration:");
+    console.log(`  Config file: ${profileExists() ? getConfigDir() + "/config.json" : "(not saved — using env vars)"}`);
+    console.log(`  API URL:     ${cfg.apiUrl}`);
+    console.log(`  API Key:     ${cfg.apiKey ? cfg.apiKey.slice(0, 11) + "..." : "(not set)"}`);
+    console.log(`  Worker name: ${cfg.workerName}`);
+    console.log(`  Platform:    ${os.platform()}/${os.arch()}`);
+    if (!cfg.apiKey) {
+        console.log("\nNot configured. Run 'cloudcontrol login' first.");
+        return;
+    }
+    // Check cloud connection
+    console.log("\nCloud connection:");
+    try {
+        const res = await fetch(`${cfg.apiUrl}/api/health`);
+        const data = await res.json();
+        console.log(`  Status:      ${data.status}`);
+        if (data.coordinator)
+            console.log(`  Coordinator: ${data.coordinator.running ? "running" : "stopped"}`);
+        if (data.scheduler)
+            console.log(`  Scheduler:   ${data.scheduler.running ? "running" : "stopped"}`);
+    }
+    catch (err) {
+        console.log(`  Error:       Could not reach ${cfg.apiUrl}`);
+    }
+    // Show models
+    const router = new ModelRouter();
+    const models = router.listModels();
+    console.log(`\nModels: ${models.map((m) => m.name).join(", ") || "none"}`);
+    console.log(`Default: ${router.getDefault()}`);
+    console.log(`\nDaemon service: ${serviceStatus()}`);
+});
+// ── mcp ──────────────────────────────────────────────
+program
+    .command("mcp")
+    .description("Start the MCP server for Claude Desktop (stdio transport)")
+    .option("--profile <name>", "Company profile to use")
+    .action(async (opts) => {
+    if (opts.profile)
+        process.env.CLOUDCONTROL_PROFILE = opts.profile;
+    await import("./mcp-server.js");
+});
+// ── start ─────────────────────────────────────────────
+program
+    .command("start")
+    .description("Start the daemon and begin processing tasks")
+    .option("--profile <name>", "Company profile to use", "default")
+    .option("--api-url <url>", "CloudControl API URL (overrides profile)")
+    .option("--api-key <key>", "API key (overrides profile)")
+    .option("--name <name>", "Worker name")
+    .option("--worker-type <type>", "Worker type (daemon, cli, ide)", "daemon")
+    .option("--capabilities <list>", "Comma-separated capabilities", "browser,filesystem,shell,ai_execution")
+    .option("--task-types <list>", "Comma-separated task types to accept (empty = all)")
+    .option("--poll-interval <ms>", "Poll interval in milliseconds", "15000")
+    .option("--model <model>", "Override default model for all tasks")
+    .option("--all", "Start workers for ALL saved company profiles")
+    .action(async (opts) => {
+    if (opts.all) {
+        const { startAllProfiles } = await import("./multi-profile.js");
+        const shutdown = await startAllProfiles({
+            workerType: opts.workerType,
+            capabilities: opts.capabilities?.split(",").map((s) => s.trim()),
+            pollInterval: parseInt(opts.pollInterval),
+            model: opts.model,
+        });
+        const stop = () => {
+            console.log("\n[daemon] Shutting down all workers...");
+            shutdown();
+            process.exit(0);
+        };
+        process.on("SIGINT", stop);
+        process.on("SIGTERM", stop);
+        return;
+    }
+    const cfg = loadConfig({
+        profileName: opts.profile,
+        apiUrl: opts.apiUrl,
+        apiKey: opts.apiKey,
+        workerName: opts.name,
+        workerType: opts.workerType,
+        capabilities: opts.capabilities?.split(",").map((s) => s.trim()),
+        taskTypeFilter: opts.taskTypes ? opts.taskTypes.split(",").map((s) => s.trim()) : undefined,
+        pollInterval: parseInt(opts.pollInterval),
+        model: opts.model,
+    });
+    if (!cfg.apiKey) {
+        console.error("Error: API key required.");
+        console.error("Run 'cloudcontrol login' or set CLOUDCONTROL_API_KEY.");
+        process.exit(1);
+    }
+    // Set up executor (initializes model router)
+    const executor = new TaskExecutor(cfg);
+    const availableModels = executor.getAvailableModels();
+    console.log(`
+┌─────────────────────────────────────┐
+│       CloudControl Daemon v${DAEMON_VERSION.padEnd(7)}│
+├─────────────────────────────────────┤
+│  Worker: ${cfg.workerName.padEnd(27)}│
+│  Type:   ${cfg.workerType.padEnd(27)}│
+│  API:    ${cfg.apiUrl.padEnd(27)}│
+│  Platform: ${(os.platform() + "/" + os.arch()).padEnd(25)}│
+│  Poll:   ${(cfg.pollInterval / 1000 + "s").padEnd(27)}│
+│  Models: ${availableModels.map((m) => m.name).join(", ").padEnd(27)}│
+└─────────────────────────────────────┘
+`);
+    // Register worker (with retry)
+    console.log("[daemon] Registering worker...");
+    let worker;
+    try {
+        const registerRes = await fetchWithRetry(`${cfg.apiUrl}/api/workers`, {
+            method: "POST",
+            headers: {
+                authorization: `Bearer ${cfg.apiKey}`,
+                "content-type": "application/json",
+            },
+            body: JSON.stringify({
+                name: cfg.workerName,
+                workerType: cfg.workerType,
+                connectionMode: "poll",
+                platform: os.platform(),
+                capabilities: cfg.capabilities,
+                taskTypeFilter: cfg.taskTypeFilter,
+                metadata: {
+                    arch: os.arch(),
+                    nodeVersion: process.version,
+                    daemonVersion: DAEMON_VERSION,
+                    availableModels,
+                },
+            }),
+        }, {
+            maxRetries: 5,
+            baseDelayMs: 2000,
+            onRetry: (attempt, err) => {
+                console.log(`[daemon] Registration retry ${attempt}: ${err.message}`);
+            },
+        });
+        ({ worker } = await registerRes.json());
+    }
+    catch (err) {
+        console.error(`[daemon] Failed to register after retries: ${err.message}`);
+        process.exit(1);
+    }
+    console.log(`[daemon] 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)}`);
+            return;
+        }
+        executing = true;
+        try {
+            sendHeartbeat("busy");
+            const task = await executor.claimTask(taskId);
+            if (!task)
+                return;
+            console.log(`[daemon] Claimed: ${task.title}`);
+            await executor.executeTask(task);
+        }
+        catch (err) {
+            console.error(`[daemon] Execution error:`, err.message);
+        }
+        finally {
+            executing = false;
+            sendHeartbeat("online");
+        }
+    }
+    async function sendHeartbeat(status = "online") {
+        try {
+            await fetchWithRetry(`${cfg.apiUrl}/api/workers/heartbeat`, {
+                method: "POST",
+                headers: {
+                    authorization: `Bearer ${cfg.apiKey}`,
+                    "content-type": "application/json",
+                },
+                body: JSON.stringify({ workerId: worker.id, status }),
+            }, { maxRetries: 2, baseDelayMs: 1000 });
+        }
+        catch {
+            // non-fatal
+        }
+    }
+    async function pollForTasks() {
+        if (executing)
+            return;
+        try {
+            const pending = await executor.pollTasks();
+            if (pending.length > 0) {
+                console.log(`[daemon] Found ${pending.length} pending task(s)`);
+                await executeTask(pending[0].id);
+            }
+        }
+        catch {
+            // non-fatal
+        }
+    }
+    const pollTimer = setInterval(pollForTasks, cfg.pollInterval);
+    const heartbeatTimer = setInterval(() => sendHeartbeat(), cfg.heartbeatInterval);
+    pollForTasks();
+    const shutdown = () => {
+        console.log("\n[daemon] 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.`);
+});
+program.parse();
+//# sourceMappingURL=cli.js.map

package/dist/config.d.ts

@@ -0,0 +1,13 @@
+export interface DaemonConfig {
+    apiUrl: string;
+    apiKey: string;
+    workerName: string;
+    workerType: string;
+    capabilities: string[];
+    taskTypeFilter?: string[];
+    pollInterval: number;
+    heartbeatInterval: number;
+    model?: string;
+    profileName?: string;
+}
+export declare function loadConfig(overrides?: Partial<DaemonConfig>): DaemonConfig;