@workermill/agent 0.1.0

package/dist/commands/setup.js

@@ -0,0 +1,396 @@
+/**
+ * Setup Wizard — Interactive configuration for the WorkerMill Remote Agent.
+ *
+ * Prerequisites checked/installed:
+ *   - Docker Desktop (must be installed manually)
+ *   - Git for Windows (must be installed manually — required by Claude Code on Windows)
+ *   - Claude CLI → winget on Windows, curl | bash on Linux/macOS/WSL
+ *   - Claude auth → launches `claude` which prompts for sign-in on first run
+ *   - Worker image → `docker pull public.ecr.aws/a7k5r0v0/workermill-worker:latest`
+ */
+import chalk from "chalk";
+import ora from "ora";
+import inquirer from "inquirer";
+import { execSync, spawnSync } from "child_process";
+import { existsSync } from "fs";
+import { hostname, homedir, totalmem, cpus } from "os";
+import { join } from "path";
+import axios from "axios";
+import { saveConfigToFile, getConfigFile, findClaudePath, } from "../config.js";
+const isWindows = process.platform === "win32";
+/**
+ * Check if a command exists in PATH.
+ */
+function commandExists(cmd) {
+    try {
+        const which = isWindows ? "where" : "which";
+        execSync(`${which} ${cmd}`, { stdio: "ignore", timeout: 10000 });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Get version string from a command, or null.
+ */
+function getVersion(cmd) {
+    try {
+        return execSync(`"${cmd}" --version`, { encoding: "utf-8", timeout: 10000 }).trim();
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Find Git Bash on Windows. Returns path to bash.exe or null.
+ */
+function findGitBash() {
+    if (!isWindows)
+        return null; // Not needed on non-Windows
+    // Check if git is in PATH (Git for Windows adds it)
+    if (commandExists("git")) {
+        try {
+            const gitPath = execSync("where git", { encoding: "utf-8", timeout: 10000 }).trim().split("\n")[0];
+            // git.exe is at Git/cmd/git.exe, bash.exe is at Git/bin/bash.exe
+            const gitDir = join(gitPath, "..", "..", "bin", "bash.exe");
+            if (existsSync(gitDir))
+                return gitDir;
+        }
+        catch { /* ignore */ }
+    }
+    // Check common install locations
+    const candidates = [
+        join(process.env.ProgramFiles || "C:\\Program Files", "Git", "bin", "bash.exe"),
+        "C:\\Program Files\\Git\\bin\\bash.exe",
+        "C:\\Program Files (x86)\\Git\\bin\\bash.exe",
+        join(homedir(), "scoop", "apps", "git", "current", "bin", "bash.exe"),
+    ];
+    for (const candidate of candidates) {
+        if (existsSync(candidate))
+            return candidate;
+    }
+    return null;
+}
+/**
+ * Install Claude CLI using the official installer.
+ * Returns true on success.
+ */
+function installClaudeCli() {
+    if (isWindows) {
+        // Windows: use winget (built into Windows 10/11)
+        try {
+            execSync("winget install Anthropic.ClaudeCode --accept-package-agreements --accept-source-agreements", { stdio: "inherit", timeout: 180_000 });
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    else {
+        // macOS: try Homebrew first
+        if (process.platform === "darwin") {
+            try {
+                execSync("brew install --cask claude-code", { stdio: "inherit", timeout: 180_000 });
+                return true;
+            }
+            catch { /* fall through */ }
+        }
+        // Linux, WSL, macOS fallback: native installer
+        try {
+            execSync("curl -fsSL https://claude.ai/install.sh | bash", { stdio: "inherit", timeout: 120_000 });
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+}
+export async function setupCommand() {
+    // Welcome banner
+    console.log();
+    console.log(chalk.bold.cyan("  WorkerMill Remote Agent Setup"));
+    console.log(chalk.dim("  ─────────────────────────────────────"));
+    console.log();
+    console.log("  Run AI workers locally with your Claude Max subscription.");
+    console.log("  Workers execute on your machine, logs stream to the cloud dashboard.");
+    console.log();
+    // ── Step 0: System Requirements ───────────────────────────────────────────
+    const totalRamGB = Math.round(totalmem() / (1024 * 1024 * 1024));
+    const cpuCount = cpus().length;
+    console.log(chalk.dim("  System"));
+    console.log(`  ${chalk.dim("RAM:")}  ${totalRamGB} GB   ${chalk.dim("CPUs:")} ${cpuCount}`);
+    if (totalRamGB < 8) {
+        console.log();
+        console.log(chalk.red("  ✗ Insufficient RAM"));
+        console.log(chalk.yellow("  WorkerMill requires at least 8 GB of RAM (16 GB recommended)."));
+        console.log(chalk.yellow(`  Your system has ${totalRamGB} GB.`));
+        console.log();
+        process.exit(1);
+    }
+    else if (totalRamGB < 16) {
+        console.log(chalk.yellow(`  ⚠ ${totalRamGB} GB RAM is below the recommended 16 GB.`));
+        console.log(chalk.yellow("    Workers may run slowly or be killed by the OS under memory pressure."));
+    }
+    else {
+        console.log(chalk.green("  ✓ System meets requirements"));
+    }
+    console.log();
+    // ── Step 1: Docker ────────────────────────────────────────────────────────
+    const dockerSpinner = ora("Checking Docker...").start();
+    if (commandExists("docker")) {
+        const version = getVersion("docker");
+        // Verify Docker daemon is actually running (not just the CLI installed)
+        try {
+            const osType = execSync("docker info --format {{.OSType}}", {
+                encoding: "utf-8",
+                timeout: 15000,
+            }).trim();
+            // On Windows, verify Linux containers mode
+            if (isWindows && osType === "windows") {
+                dockerSpinner.fail("Docker is running in Windows containers mode");
+                console.log();
+                console.log(chalk.yellow("  WorkerMill workers require Linux containers."));
+                console.log(chalk.yellow("  Right-click the Docker Desktop icon in the system tray →"));
+                console.log(chalk.yellow("  'Switch to Linux containers...'"));
+                console.log();
+                console.log("  Then re-run: workermill-agent");
+                process.exit(1);
+            }
+        }
+        catch {
+            dockerSpinner.fail("Docker is installed but the daemon is not running");
+            console.log();
+            console.log(chalk.yellow("  Start Docker Desktop, wait for it to fully initialize,"));
+            console.log(chalk.yellow("  then re-run: workermill-agent"));
+            process.exit(1);
+        }
+        dockerSpinner.succeed(`Docker ${chalk.dim(version ? `(${version})` : "")}`);
+    }
+    else {
+        dockerSpinner.fail("Docker is not installed");
+        console.log();
+        console.log(chalk.yellow("  Docker Desktop is required but must be installed manually:"));
+        console.log(`  ${chalk.cyan("https://docs.docker.com/get-docker/")}`);
+        console.log();
+        console.log("  Install Docker, start it, then re-run: workermill-agent");
+        process.exit(1);
+    }
+    // ── Step 2: Git for Windows (required by Claude Code on Windows) ────────
+    if (isWindows) {
+        const gitSpinner = ora("Checking Git for Windows...").start();
+        const gitBashPath = findGitBash();
+        if (gitBashPath) {
+            gitSpinner.succeed(`Git for Windows ${chalk.dim(`(${gitBashPath})`)}`);
+            // Set CLAUDE_CODE_GIT_BASH_PATH so Claude can find it
+            process.env.CLAUDE_CODE_GIT_BASH_PATH = gitBashPath;
+        }
+        else {
+            gitSpinner.fail("Git for Windows is not installed");
+            console.log();
+            console.log(chalk.yellow("  Claude Code on Windows requires Git for Windows (Git Bash):"));
+            console.log(`  ${chalk.cyan("https://git-scm.com/downloads/win")}`);
+            console.log();
+            console.log("  Install Git for Windows, then re-run: workermill-agent");
+            process.exit(1);
+        }
+    }
+    // ── Step 3: Claude CLI ────────────────────────────────────────────────────
+    const claudeSpinner = ora("Checking Claude CLI...").start();
+    let claudePath = findClaudePath();
+    if (claudePath) {
+        const version = getVersion(claudePath);
+        claudeSpinner.succeed(`Claude CLI ${chalk.dim(version ? `(${version})` : "")}`);
+    }
+    else {
+        claudeSpinner.warn("Claude CLI not found — installing...");
+        console.log();
+        const installed = installClaudeCli();
+        if (installed) {
+            claudePath = findClaudePath();
+        }
+        if (claudePath) {
+            const version = getVersion(claudePath);
+            console.log();
+            console.log(chalk.green(`  ✓ Claude CLI installed ${chalk.dim(version ? `(${version})` : "")}`));
+        }
+        else {
+            console.log();
+            console.log(chalk.red("  Claude CLI was installed but could not be found."));
+            console.log();
+            if (isWindows) {
+                console.log(chalk.yellow("  Winget updated your PATH but this shell doesn't have it yet."));
+                console.log(chalk.yellow("  Close this terminal, open a new one, and re-run: workermill-agent"));
+            }
+            else {
+                console.log("  Try manually:");
+                console.log(chalk.cyan("    curl -fsSL https://claude.ai/install.sh | bash"));
+                console.log("  Then re-run: workermill-agent");
+            }
+            process.exit(1);
+        }
+    }
+    // ── Step 4: Claude auth ───────────────────────────────────────────────────
+    const authSpinner = ora("Checking Claude authentication...").start();
+    const credsPath = join(homedir(), ".claude", ".credentials.json");
+    if (existsSync(credsPath)) {
+        authSpinner.succeed("Claude authenticated");
+    }
+    else {
+        authSpinner.warn("Not authenticated — launching Claude...");
+        console.log();
+        console.log(chalk.dim("  Claude will open and prompt you to authenticate."));
+        console.log(chalk.dim("  Sign in with your Claude Max account, then exit Claude (Ctrl+C)."));
+        console.log();
+        // Pass Git Bash path on Windows so Claude can find it
+        const env = { ...process.env };
+        if (isWindows) {
+            const gitBash = findGitBash();
+            if (gitBash)
+                env.CLAUDE_CODE_GIT_BASH_PATH = gitBash;
+        }
+        spawnSync(claudePath, [], {
+            stdio: "inherit",
+            timeout: 300_000,
+            env,
+        });
+        if (existsSync(credsPath)) {
+            console.log();
+            console.log(chalk.green("  ✓ Claude authenticated"));
+        }
+        else {
+            console.log();
+            console.log(chalk.red("  Authentication failed or was cancelled."));
+            console.log(`  Try manually: open a new terminal and run 'claude'`);
+            console.log("  Then re-run: workermill-agent");
+            process.exit(1);
+        }
+    }
+    // ── Step 5: Node.js ──────────────────────────────────────────────────────
+    console.log(chalk.green("  ✓") + ` Node.js ${chalk.dim(`(${process.version})`)}`);
+    console.log();
+    // ── Step 6: Configuration prompts ─────────────────────────────────────────
+    console.log(chalk.bold("Configuration"));
+    console.log();
+    const { apiUrl } = await inquirer.prompt([
+        {
+            type: "input",
+            name: "apiUrl",
+            message: "WorkerMill API URL:",
+            default: "https://workermill.com",
+            validate: (v) => v.startsWith("http://") || v.startsWith("https://") ? true : "Must be a valid URL",
+        },
+    ]);
+    const { apiKey } = await inquirer.prompt([
+        {
+            type: "password",
+            name: "apiKey",
+            message: "API Key (from Settings > Integrations):",
+            mask: "*",
+            validate: (v) => (v.length > 0 ? true : "API key is required"),
+        },
+    ]);
+    // Validate API key
+    const validateSpinner = ora("Validating API key...").start();
+    let scmProvider = "github";
+    try {
+        const resp = await axios.get(`${apiUrl.replace(/\/$/, "")}/api/agent/config`, {
+            headers: { "x-api-key": apiKey },
+            timeout: 15000,
+        });
+        scmProvider = resp.data.scmProvider || "github";
+        validateSpinner.succeed(`Connected! SCM provider: ${scmProvider}`);
+    }
+    catch (error) {
+        const err = error;
+        if (err.response?.status === 401) {
+            validateSpinner.fail("Invalid API key. Check Settings > Integrations on the dashboard.");
+        }
+        else {
+            validateSpinner.fail("Failed to connect to WorkerMill API. Check the URL and try again.");
+        }
+        process.exit(1);
+    }
+    // SCM token
+    const tokenPrompts = {
+        github: "",
+        bitbucket: "",
+        gitlab: "",
+    };
+    const scmLabel = scmProvider === "bitbucket"
+        ? "Bitbucket"
+        : scmProvider === "gitlab"
+            ? "GitLab"
+            : "GitHub";
+    const { scmToken } = await inquirer.prompt([
+        {
+            type: "password",
+            name: "scmToken",
+            message: `${scmLabel} personal access token (for cloning/pushing to your repos):`,
+            mask: "*",
+            validate: (v) => (v.length > 0 ? true : "A token is required for workers to clone and push to your repositories"),
+        },
+    ]);
+    if (scmToken) {
+        tokenPrompts[scmProvider] = scmToken;
+    }
+    const { agentId } = await inquirer.prompt([
+        {
+            type: "input",
+            name: "agentId",
+            message: "Agent name:",
+            default: `agent-${hostname()}`,
+        },
+    ]);
+    // ── Step 7: Pull worker image ─────────────────────────────────────────────
+    console.log();
+    const workerImage = "public.ecr.aws/a7k5r0v0/workermill-worker:latest";
+    console.log(chalk.dim(`  Pulling worker image: ${workerImage}`));
+    console.log(chalk.dim("  This may take a few minutes on first run (~1.1 GB)..."));
+    console.log();
+    // Use spawnSync to show progress AND capture errors
+    const pullResult = spawnSync("docker", ["pull", workerImage], {
+        stdio: "inherit",
+        timeout: 600_000, // 10 minutes
+    });
+    if (pullResult.status === 0) {
+        console.log();
+        console.log(chalk.green(`  ✓ Worker image pulled`));
+    }
+    else {
+        console.log();
+        console.log(chalk.red("  ✗ Failed to pull worker image."));
+        console.log();
+        if (pullResult.error) {
+            console.log(chalk.yellow(`  Error: ${pullResult.error.message}`));
+        }
+        console.log(chalk.yellow("  Troubleshooting:"));
+        console.log(chalk.yellow("    1. Is Docker Desktop running?"));
+        if (isWindows) {
+            console.log(chalk.yellow("    2. Is Docker in Linux containers mode? (Right-click Docker tray icon)"));
+        }
+        console.log(chalk.yellow(`    ${isWindows ? "3" : "2"}. Try manually: ${chalk.cyan(`docker pull ${workerImage}`)}`));
+        console.log();
+        console.log(chalk.dim("  Setup will continue — you can pull the image later before starting."));
+    }
+    // ── Step 8: Save config ───────────────────────────────────────────────────
+    const fileConfig = {
+        apiUrl: apiUrl.replace(/\/$/, ""),
+        apiKey,
+        agentId,
+        maxWorkers: 1,
+        pollIntervalMs: 5000,
+        heartbeatIntervalMs: 30000,
+        tokens: tokenPrompts,
+        workerImage,
+        setupCompletedAt: new Date().toISOString(),
+    };
+    saveConfigToFile(fileConfig);
+    console.log();
+    console.log(chalk.green.bold("  Setup complete!"));
+    console.log();
+    console.log(`  Config saved to: ${chalk.dim(getConfigFile())}`);
+    console.log();
+    console.log(`  Start the agent with: ${chalk.cyan("workermill-agent start")}`);
+    console.log();
+}

package/dist/commands/start.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Start Command — Start the WorkerMill Remote Agent.
+ *
+ * Loads config from ~/.workermill/config.json, validates prerequisites,
+ * registers with the cloud API, and starts polling.
+ *
+ * Supports --detach mode for running as a daemon.
+ */
+export declare function startCommand(options: {
+    detach?: boolean;
+}): Promise<void>;

package/dist/commands/start.js

@@ -0,0 +1,117 @@
+/**
+ * Start Command — Start the WorkerMill Remote Agent.
+ *
+ * Loads config from ~/.workermill/config.json, validates prerequisites,
+ * registers with the cloud API, and starts polling.
+ *
+ * Supports --detach mode for running as a daemon.
+ */
+import chalk from "chalk";
+import { totalmem } from "os";
+import { spawn } from "child_process";
+import { writeFileSync, existsSync, unlinkSync, openSync } from "fs";
+import { loadConfigFromFile, checkPrerequisites, getSystemInfo, getPidFile, getLogFile, getConfigFile, } from "../config.js";
+import { startAgent } from "../index.js";
+export async function startCommand(options) {
+    // Check config exists
+    if (!existsSync(getConfigFile())) {
+        console.log(chalk.red("No configuration found."));
+        console.log(`Run ${chalk.cyan("workermill-agent setup")} first.`);
+        process.exit(1);
+    }
+    const config = loadConfigFromFile();
+    // Validate prerequisites
+    const prereqs = checkPrerequisites(config.workerImage);
+    const failing = prereqs.filter((p) => !p.ok);
+    // Auto-pull worker image if it's the only missing prereq
+    const imageMissing = failing.find((p) => p.name === "Worker image");
+    const otherFailing = failing.filter((p) => p.name !== "Worker image");
+    if (otherFailing.length > 0) {
+        console.log(chalk.red("Prerequisites check failed:"));
+        for (const p of otherFailing) {
+            console.log(chalk.red(`  ✗ ${p.name}: ${p.detail}`));
+        }
+        process.exit(1);
+    }
+    if (imageMissing) {
+        console.log(chalk.yellow(`  Worker image not found locally. Pulling ${config.workerImage}...`));
+        const { spawnSync } = await import("child_process");
+        const pull = spawnSync("docker", ["pull", config.workerImage], {
+            stdio: "inherit",
+            timeout: 600_000,
+        });
+        if (pull.status !== 0) {
+            console.log(chalk.red(`  Failed to pull worker image.`));
+            process.exit(1);
+        }
+        console.log(chalk.green(`  ✓ Worker image pulled`));
+    }
+    if (options.detach) {
+        const logFile = getLogFile();
+        const pidFile = getPidFile();
+        console.log(chalk.dim(`Starting agent in background...`));
+        console.log(chalk.dim(`  Logs: ${logFile}`));
+        console.log(chalk.dim(`  PID:  ${pidFile}`));
+        // Spawn the CLI with "start" (no --detach) as a detached child, redirecting output to log file
+        const logFd = openSync(logFile, "a");
+        const child = spawn("workermill-agent", ["start"], {
+            detached: true,
+            stdio: ["ignore", logFd, logFd],
+            shell: true, // Required on Windows to find .cmd wrappers
+        });
+        if (child.pid) {
+            writeFileSync(pidFile, String(child.pid), "utf-8");
+            child.unref();
+            console.log(chalk.green(`Agent started (PID: ${child.pid})`));
+            console.log(`Check status with: ${chalk.cyan("workermill-agent status")}`);
+        }
+        else {
+            console.log(chalk.red("Failed to start agent in background."));
+            process.exit(1);
+        }
+        return;
+    }
+    // Foreground mode
+    console.log();
+    console.log(chalk.bold.cyan("  WorkerMill Remote Agent"));
+    console.log(chalk.dim("  ─────────────────────────────────────"));
+    console.log();
+    // RAM check
+    const totalRamGB = Math.round(totalmem() / (1024 * 1024 * 1024));
+    if (totalRamGB < 8) {
+        console.log(chalk.red(`  ✗ Insufficient RAM: ${totalRamGB} GB (minimum 8 GB, recommended 16 GB)`));
+        process.exit(1);
+    }
+    else if (totalRamGB < 16) {
+        console.log(chalk.yellow(`  ⚠ RAM: ${totalRamGB} GB (below recommended 16 GB — workers may be slow)`));
+    }
+    // Register with system info
+    const sysInfo = getSystemInfo();
+    console.log(chalk.dim(`  Agent:    ${config.agentId}`));
+    console.log(chalk.dim(`  Host:     ${sysInfo.hostname}`));
+    console.log(chalk.dim(`  Platform: ${sysInfo.platform}`));
+    console.log(chalk.dim(`  Image:    ${config.workerImage}`));
+    console.log();
+    try {
+        const cleanup = await startAgent(config);
+        // Write PID file for status command
+        writeFileSync(getPidFile(), String(process.pid), "utf-8");
+        // Graceful shutdown
+        const shutdown = async () => {
+            await cleanup();
+            try {
+                unlinkSync(getPidFile());
+            }
+            catch {
+                /* ignore */
+            }
+            process.exit(0);
+        };
+        process.on("SIGINT", shutdown);
+        process.on("SIGTERM", shutdown);
+    }
+    catch (error) {
+        console.log(chalk.red(`Failed to start: ${error instanceof Error ? error.message : String(error)}`));
+        process.exit(1);
+    }
+}

package/dist/commands/status.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Status Command — Show the current state of the WorkerMill Remote Agent.
+ *
+ * Displays: running/stopped, agent ID, active containers, API connectivity.
+ */
+export declare function statusCommand(): Promise<void>;

package/dist/commands/status.js

@@ -0,0 +1,86 @@
+/**
+ * Status Command — Show the current state of the WorkerMill Remote Agent.
+ *
+ * Displays: running/stopped, agent ID, active containers, API connectivity.
+ */
+import chalk from "chalk";
+import { existsSync, readFileSync } from "fs";
+import { execSync } from "child_process";
+import axios from "axios";
+import { getPidFile, getConfigFile, loadConfigFromFile } from "../config.js";
+export async function statusCommand() {
+    console.log();
+    console.log(chalk.bold("WorkerMill Remote Agent Status"));
+    console.log(chalk.dim("─────────────────────────────────────"));
+    console.log();
+    // Check config
+    if (!existsSync(getConfigFile())) {
+        console.log(chalk.yellow("  Not configured. Run 'workermill-agent setup' first."));
+        return;
+    }
+    const config = loadConfigFromFile();
+    // Agent process status
+    const pidFile = getPidFile();
+    let isRunning = false;
+    let pid = null;
+    if (existsSync(pidFile)) {
+        const pidStr = readFileSync(pidFile, "utf-8").trim();
+        pid = parseInt(pidStr, 10);
+        if (!isNaN(pid)) {
+            try {
+                process.kill(pid, 0);
+                isRunning = true;
+            }
+            catch {
+                isRunning = false;
+            }
+        }
+    }
+    const statusIcon = isRunning ? chalk.green("● online") : chalk.red("● offline");
+    console.log(`  Status:      ${statusIcon}${pid ? chalk.dim(` (PID ${pid})`) : ""}`);
+    console.log(`  Agent ID:    ${config.agentId}`);
+    console.log(`  API URL:     ${config.apiUrl}`);
+    console.log(`  Max workers: ${config.maxWorkers}`);
+    console.log(`  Image:       ${config.workerImage}`);
+    // Active containers
+    console.log();
+    console.log(chalk.bold("  Active Containers"));
+    try {
+        const output = execSync('docker ps --filter "name=workermill-" --format "{{.Names}}\t{{.Status}}\t{{.RunningFor}}"', { encoding: "utf-8", timeout: 10000 }).trim();
+        if (output) {
+            const lines = output.split("\n");
+            console.log(chalk.dim(`  Found ${lines.length} container(s):`));
+            for (const line of lines) {
+                const [name, status, running] = line.split("\t");
+                console.log(`    ${chalk.cyan(name)}  ${status}  ${chalk.dim(running || "")}`);
+            }
+        }
+        else {
+            console.log(chalk.dim("  No active containers"));
+        }
+    }
+    catch {
+        console.log(chalk.dim("  Could not query Docker"));
+    }
+    // API connectivity
+    console.log();
+    console.log(chalk.bold("  API Connectivity"));
+    try {
+        const resp = await axios.get(`${config.apiUrl}/api/agent/config`, {
+            headers: { "x-api-key": config.apiKey },
+            timeout: 10000,
+        });
+        console.log(`  ${chalk.green("✓")} Connected to ${config.apiUrl}`);
+        console.log(chalk.dim(`    SCM: ${resp.data.scmProvider}, Model: ${resp.data.defaultWorkerModel}`));
+    }
+    catch (error) {
+        const err = error;
+        if (err.response?.status === 401) {
+            console.log(`  ${chalk.red("✗")} Authentication failed (invalid API key)`);
+        }
+        else {
+            console.log(`  ${chalk.red("✗")} Cannot reach ${config.apiUrl}`);
+        }
+    }
+    console.log();
+}

package/dist/commands/stop.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Stop Command — Stop a running WorkerMill Remote Agent daemon.
+ *
+ * Reads PID from ~/.workermill/agent.pid, sends SIGTERM, waits for exit.
+ */
+export declare function stopCommand(): Promise<void>;

package/dist/commands/stop.js

@@ -0,0 +1,61 @@
+/**
+ * Stop Command — Stop a running WorkerMill Remote Agent daemon.
+ *
+ * Reads PID from ~/.workermill/agent.pid, sends SIGTERM, waits for exit.
+ */
+import chalk from "chalk";
+import { existsSync, readFileSync, unlinkSync } from "fs";
+import { getPidFile } from "../config.js";
+export async function stopCommand() {
+    const pidFile = getPidFile();
+    if (!existsSync(pidFile)) {
+        console.log(chalk.yellow("No running agent found (no PID file)."));
+        console.log(chalk.dim(`Expected PID file at: ${pidFile}`));
+        return;
+    }
+    const pidStr = readFileSync(pidFile, "utf-8").trim();
+    const pid = parseInt(pidStr, 10);
+    if (isNaN(pid)) {
+        console.log(chalk.red(`Invalid PID in ${pidFile}: ${pidStr}`));
+        unlinkSync(pidFile);
+        return;
+    }
+    // Check if process is running
+    try {
+        process.kill(pid, 0); // Signal 0 = check existence
+    }
+    catch {
+        console.log(chalk.yellow(`Agent (PID ${pid}) is not running. Cleaning up PID file.`));
+        unlinkSync(pidFile);
+        return;
+    }
+    // Send SIGTERM
+    console.log(chalk.dim(`Stopping agent (PID ${pid})...`));
+    try {
+        process.kill(pid, "SIGTERM");
+    }
+    catch (error) {
+        console.log(chalk.red(`Failed to stop agent: ${error instanceof Error ? error.message : String(error)}`));
+        return;
+    }
+    // Wait for process to exit (up to 15 seconds)
+    const start = Date.now();
+    while (Date.now() - start < 15000) {
+        try {
+            process.kill(pid, 0);
+            await new Promise((r) => setTimeout(r, 500));
+        }
+        catch {
+            // Process has exited
+            break;
+        }
+    }
+    // Clean up PID file
+    try {
+        unlinkSync(pidFile);
+    }
+    catch {
+        /* ignore */
+    }
+    console.log(chalk.green("Agent stopped."));
+}