@workermill/agent 0.1.0

package/dist/spawner.js

@@ -0,0 +1,290 @@
+/**
+ * Remote Agent Spawner
+ *
+ * Spawns Docker worker containers that talk directly to the cloud WorkerMill API.
+ * Extracted from api/src/services/local-epic-spawner.ts with key differences:
+ *   - API_BASE_URL points to cloud (https://workermill.com)
+ *   - ORG_API_KEY is the real org API key
+ *   - Container logs stream to cloud dashboard via SSE
+ */
+import chalk from "chalk";
+import { spawn, execSync } from "child_process";
+import * as path from "path";
+import * as fs from "fs";
+import * as os from "os";
+/** Timestamp prefix */
+function ts() {
+    return chalk.dim(new Date().toLocaleTimeString());
+}
+// Track active containers
+const activeContainers = new Map();
+/**
+ * Detect if running in WSL.
+ */
+function detectWSL() {
+    if (process.env.WSL_DISTRO_NAME || process.env.WSL_INTEROP)
+        return true;
+    try {
+        const procVersion = fs.readFileSync("/proc/version", "utf-8");
+        return procVersion.toLowerCase().includes("microsoft");
+    }
+    catch {
+        return false;
+    }
+}
+const isWSL = detectWSL();
+const isDockerDesktop = isWSL || process.platform === "darwin" || process.platform === "win32";
+/**
+ * Convert WSL paths to Windows paths for Docker volume mounts.
+ */
+function toDockerPath(unixPath) {
+    if (!isWSL)
+        return unixPath;
+    const match = unixPath.match(/^\/mnt\/([a-zA-Z])\/(.*)$/);
+    if (match)
+        return `${match[1].toUpperCase()}:/${match[2]}`;
+    return unixPath;
+}
+/**
+ * Find Claude config directory (handles WSL).
+ */
+function findClaudeConfigDir() {
+    const standardDir = path.join(os.homedir(), ".claude");
+    if (fs.existsSync(standardDir))
+        return standardDir;
+    if (isWSL) {
+        const windowsUsersDir = "/mnt/c/Users";
+        if (fs.existsSync(windowsUsersDir)) {
+            try {
+                for (const user of fs.readdirSync(windowsUsersDir)) {
+                    if (["Public", "Default", "Default User", "All Users"].includes(user))
+                        continue;
+                    const claudeDir = path.join(windowsUsersDir, user, ".claude");
+                    if (fs.existsSync(claudeDir))
+                        return claudeDir;
+                }
+            }
+            catch { /* ignore */ }
+        }
+    }
+    return null;
+}
+/**
+ * Get SCM token based on provider.
+ */
+function getScmToken(scmProvider, config) {
+    switch (scmProvider) {
+        case "bitbucket": return config.bitbucketToken;
+        case "gitlab": return config.gitlabToken;
+        default: return config.githubToken;
+    }
+}
+/** Check if a task has the self-review label (works across Jira, GitHub, GitLab, Linear) */
+function hasSelfReviewLabel(task) {
+    const fields = task.jiraFields;
+    if (!fields)
+        return false;
+    // Jira: labels is a string array at top level
+    const jiraLabels = fields.labels;
+    if (Array.isArray(jiraLabels) && jiraLabels.some((l) => typeof l === "string" && l.toLowerCase() === "self-review"))
+        return true;
+    // GitHub/GitLab: labels are in nested issue object with {name: string} shape
+    const issue = fields.issue;
+    const issueLabels = issue?.labels;
+    if (Array.isArray(issueLabels) && issueLabels.some((l) => {
+        if (typeof l === "string")
+            return l.toLowerCase() === "self-review";
+        if (l && typeof l === "object" && "name" in l)
+            return (l.name || "").toLowerCase() === "self-review";
+        return false;
+    }))
+        return true;
+    return false;
+}
+/**
+ * Spawn a Docker worker container for a task.
+ */
+export async function spawnWorker(task, config, orgConfig) {
+    const taskLabel = chalk.cyan(task.id.slice(0, 8));
+    if (activeContainers.has(task.id)) {
+        console.log(`${ts()} ${taskLabel} ${chalk.dim("Already running, skipping")}`);
+        return;
+    }
+    const containerName = `workermill-${task.id.slice(0, 8)}`;
+    // Build Docker run arguments
+    const dockerArgs = ["run", "--rm", "--pull", "always", "--name", containerName];
+    // Resource limits — 6GB memory with swap for overflow.
+    // NODE_OPTIONS caps V8 heap at 2GB; the extra room is for git, npm, Claude CLI subprocesses.
+    const totalRamGB = Math.round(os.totalmem() / (1024 * 1024 * 1024));
+    if (totalRamGB <= 16) {
+        dockerArgs.push("--memory", "6g", "--memory-swap", "10g", "--cpus", "2");
+    }
+    else if (totalRamGB <= 32) {
+        dockerArgs.push("--memory", "6g", "--memory-swap", "12g", "--cpus", "4");
+    }
+    else {
+        dockerArgs.push("--memory", "6g", "--memory-swap", "12g", "--cpus", "4");
+    }
+    // Network mode
+    if (isDockerDesktop) {
+        dockerArgs.push("--add-host=host.docker.internal:host-gateway");
+    }
+    else {
+        dockerArgs.push("--network", "host");
+    }
+    // Mount Claude credentials
+    const claudeConfigDir = findClaudeConfigDir();
+    if (!claudeConfigDir) {
+        console.error(`${ts()} ${taskLabel} ${chalk.red("✗")} Claude credentials not found. Run 'claude' and complete the sign-in flow.`);
+        return;
+    }
+    // Copy credentials to a temp dir with relaxed permissions for container access
+    // (avoids weakening permissions on the user's actual credentials file)
+    const credFile = path.join(claudeConfigDir, ".credentials.json");
+    const dockerClaudeDir = toDockerPath(claudeConfigDir);
+    dockerArgs.push("-v", `${dockerClaudeDir}:/home/worker/.claude`);
+    // Build environment variables — KEY DIFFERENCE: API_BASE_URL points to cloud
+    const scmProvider = (task.scmProvider || "github");
+    const scmToken = getScmToken(scmProvider, config);
+    const envVars = {
+        // Cap V8 heap to 3GB — forces aggressive GC instead of bloating to fill container.
+        // Each Claude CLI subprocess inherits this, preventing unbounded heap growth.
+        // Container has 6GB total; this leaves room for git, npm, and OS overhead.
+        NODE_OPTIONS: "--max-old-space-size=3072",
+        EPIC_MODE: "true",
+        EXECUTION_MODE: "local",
+        TASK_ID: task.id,
+        PARENT_TASK_ID: task.id,
+        JIRA_ISSUE_KEY: task.jiraIssueKey || "",
+        TASK_SUMMARY: task.summary || "",
+        TASK_DESCRIPTION: task.description || "",
+        // Cloud API — this is what makes remote agent mode work
+        API_BASE_URL: config.apiUrl,
+        ORG_API_KEY: config.apiKey,
+        // SCM configuration
+        SCM_PROVIDER: scmProvider,
+        SCM_TOKEN: scmToken,
+        GITHUB_TOKEN: config.githubToken,
+        GH_TOKEN: config.githubToken,
+        BITBUCKET_TOKEN: config.bitbucketToken,
+        BITBUCKET_USERNAME: "x-token-auth",
+        GITLAB_TOKEN: config.gitlabToken,
+        // Target repository
+        TARGET_REPO: task.githubRepo || "",
+        GITHUB_REPO: task.githubRepo || "",
+        // Worker model
+        WORKER_MODEL: task.workerModel || String(orgConfig.defaultWorkerModel || "sonnet"),
+        // Anthropic API key (if available)
+        ANTHROPIC_API_KEY: process.env.ANTHROPIC_API_KEY || "",
+        // Resilience settings from org config
+        BLOCKER_MAX_AUTO_RETRIES: String(orgConfig.blockerMaxAutoRetries ?? 3),
+        BLOCKER_AUTO_RETRY_ENABLED: orgConfig.blockerAutoRetryEnabled !== false ? "true" : "false",
+        PUSH_AFTER_COMMIT: orgConfig.pushAfterCommit !== false ? "true" : "false",
+        GRACEFUL_SHUTDOWN_ENABLED: orgConfig.gracefulShutdownEnabled !== false ? "true" : "false",
+        REVIEW_ENABLED: task.skipManagerReview === false ? "true" : "false",
+        SELF_REVIEW_ENABLED: hasSelfReviewLabel(task) || (orgConfig.selfReviewEnabled !== false) ? "true" : "false",
+    };
+    // Build -e args, filtering empty values
+    for (const [k, v] of Object.entries(envVars)) {
+        if (v !== "") {
+            dockerArgs.push("-e", `${k}=${v}`);
+        }
+    }
+    // Worker image (configurable: Docker Hub for CLI users, local for bin/remote-agent)
+    dockerArgs.push(config.workerImage || "public.ecr.aws/a7k5r0v0/workermill-worker:latest");
+    const reviewEnabled = task.skipManagerReview === false;
+    console.log(`${ts()} ${taskLabel} ${chalk.dim("Starting container")} ${chalk.yellow(containerName)}`);
+    console.log(`${ts()} ${taskLabel} ${chalk.dim(`  skipManagerReview=${task.skipManagerReview} → REVIEW_ENABLED=${reviewEnabled}`)}`);
+    console.log(`${ts()} ${taskLabel} ${chalk.dim(`  model=${task.workerModel} repo=${task.githubRepo}`)}`);
+    console.log(`${ts()} ${taskLabel} ${chalk.dim(`  totalRamGB=${totalRamGB} docker args:`)} ${dockerArgs.slice(0, 10).join(" ")}`);
+    // Spawn Docker container
+    const proc = spawn("docker", dockerArgs, {
+        stdio: ["ignore", "pipe", "pipe"],
+        detached: false,
+    });
+    if (!proc.pid) {
+        console.error(`${ts()} ${taskLabel} ${chalk.red("✗")} Failed to spawn container`);
+        return;
+    }
+    const container = {
+        taskId: task.id,
+        containerName,
+        process: proc,
+        startedAt: new Date(),
+        status: "running",
+    };
+    activeContainers.set(task.id, container);
+    // Stream stdout/stderr to console (logs go to cloud via container's own HTTP calls)
+    proc.stdout?.on("data", (data) => {
+        const lines = data.toString().split("\n").filter((l) => l.trim());
+        for (const line of lines) {
+            console.log(`${ts()} ${taskLabel} ${chalk.dim(line)}`);
+        }
+    });
+    proc.stderr?.on("data", (data) => {
+        const lines = data.toString().split("\n").filter((l) => l.trim());
+        for (const line of lines) {
+            console.log(`${ts()} ${taskLabel} ${chalk.red(line)}`);
+        }
+    });
+    // Handle exit
+    proc.on("exit", (code) => {
+        container.status = code === 0 ? "completed" : "failed";
+        const duration = Math.round((Date.now() - container.startedAt.getTime()) / 1000);
+        const icon = code === 0 ? chalk.green("✓") : chalk.red("✗");
+        const status = code === 0 ? chalk.green("completed") : chalk.red(`failed (exit ${code})`);
+        console.log(`${ts()} ${taskLabel} ${icon} Container ${status} ${chalk.dim(`(${duration}s)`)}`);
+        // Clean up after delay
+        setTimeout(() => activeContainers.delete(task.id), 60_000);
+    });
+    proc.on("error", (err) => {
+        container.status = "failed";
+        console.error(`${ts()} ${taskLabel} ${chalk.red("✗")} Container error: ${err.message}`);
+    });
+}
+/**
+ * Get count of actively running containers.
+ */
+export function getActiveCount() {
+    return Array.from(activeContainers.values()).filter((c) => c.status === "running").length;
+}
+/**
+ * Get IDs of all active tasks.
+ */
+export function getActiveTaskIds() {
+    return Array.from(activeContainers.values())
+        .filter((c) => c.status === "running")
+        .map((c) => c.taskId);
+}
+/**
+ * Stop a specific task's container by task ID.
+ */
+export function stopTask(taskId) {
+    const container = activeContainers.get(taskId);
+    if (!container || container.status !== "running")
+        return;
+    const taskLabel = chalk.cyan(taskId.slice(0, 8));
+    console.log(`${ts()} ${taskLabel} ${chalk.red("■")} Stopping container (cancelled by dashboard)`);
+    try {
+        execSync(`docker stop ${container.containerName}`, { stdio: "ignore", timeout: 15_000 });
+        container.status = "completed";
+    }
+    catch { /* may have already exited */ }
+    activeContainers.delete(taskId);
+}
+/**
+ * Stop all running containers.
+ */
+export async function stopAll() {
+    console.log(`${ts()} ${chalk.dim(`Stopping ${activeContainers.size} containers...`)}`);
+    for (const [, container] of activeContainers) {
+        if (container.status === "running") {
+            try {
+                execSync(`docker stop ${container.containerName}`, { stdio: "ignore", timeout: 15_000 });
+                container.status = "completed";
+            }
+            catch { /* may have already exited */ }
+        }
+    }
+    activeContainers.clear();
+}

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@workermill/agent",
+  "version": "0.1.0",
+  "description": "WorkerMill Remote Agent - Run AI workers locally with your Claude Max subscription",
+  "type": "module",
+  "main": "./dist/index.js",
+  "bin": {
+    "workermill-agent": "./dist/cli.js"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "typecheck": "tsc --noEmit"
+  },
+  "engines": {
+    "node": ">=20.0.0"
+  },
+  "dependencies": {
+    "axios": "^1.7.0",
+    "chalk": "^5.3.0",
+    "commander": "^12.0.0",
+    "inquirer": "^9.2.0",
+    "ora": "^8.0.0"
+  },
+  "devDependencies": {
+    "@types/inquirer": "^9.0.9",
+    "@types/node": "^22.0.0",
+    "typescript": "^5.5.0"
+  }
+}