@cloudagentfleet/worker 0.1.1

package/dist/cloudagentfleet-worker.mjs

@@ -0,0 +1,958 @@
+#!/usr/bin/env node
+
+
+// apps/node-agent/src/main.ts
+import { spawnSync } from "node:child_process";
+import { existsSync } from "node:fs";
+import { homedir } from "node:os";
+import { join as join2 } from "node:path";
+import { createHash } from "node:crypto";
+
+// apps/node-agent/src/codeman.ts
+import { readdir, realpath } from "node:fs/promises";
+import { basename, dirname, join, resolve } from "node:path";
+var CodemanApiError = class extends Error {
+  status;
+  errorCode;
+  constructor(status, message, errorCode) {
+    super(message);
+    this.name = "CodemanApiError";
+    this.status = status;
+    this.errorCode = errorCode;
+  }
+};
+var CodemanClient = class {
+  baseUrl;
+  headers;
+  fetchImpl;
+  waitTimeoutMs;
+  inputSequence = Date.now();
+  constructor(options) {
+    const baseUrl = options.baseUrl.endsWith("/") ? options.baseUrl.slice(0, -1) : options.baseUrl;
+    const parsed = new URL(baseUrl);
+    if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+      throw new Error("Codeman URL must use HTTP or HTTPS");
+    }
+    this.baseUrl = baseUrl;
+    this.fetchImpl = options.fetchImpl ?? fetch;
+    this.waitTimeoutMs = options.waitTimeoutMs ?? 6e4;
+    this.headers = { accept: "application/json" };
+    if (options.username !== void 0 || options.password !== void 0) {
+      if (!options.username || options.password === void 0) {
+        throw new Error("Codeman username and password must be provided together");
+      }
+      this.headers.authorization = `Basic ${Buffer.from(
+        `${options.username}:${options.password}`
+      ).toString("base64")}`;
+    }
+  }
+  async createSession(options) {
+    const envelope = await this.request("/api/v1/sessions", {
+      method: "POST",
+      body: {
+        workingDir: options.workingDir,
+        mode: options.mode,
+        name: options.name
+      }
+    });
+    if (!envelope.data?.session?.id) {
+      throw new CodemanApiError(200, "Codeman returned no session ID");
+    }
+    return envelope.data.session;
+  }
+  async status() {
+    return this.requestData("/api/v1/status");
+  }
+  async listSessions(includeTerminal = false) {
+    const data = await this.requestData("/api/v1/sessions");
+    const sessions = Array.isArray(data) ? data : data.sessions ?? [];
+    if (!includeTerminal) return sessions;
+    return Promise.all(sessions.map(async (session) => {
+      const sessionId = typeof session.id === "string" ? session.id : "";
+      if (!sessionId) return session;
+      try {
+        const terminal = await this.requestData(`/api/v1/sessions/${encodeURIComponent(sessionId)}/terminal?tail=20000`);
+        return {
+          ...session,
+          ...terminal.terminalBuffer === void 0 ? {} : { terminalBuffer: terminal.terminalBuffer },
+          ...terminal.status === void 0 ? {} : { status: terminal.status }
+        };
+      } catch {
+        return session;
+      }
+    }));
+  }
+  async startInteractive(sessionId) {
+    await this.request(`/api/v1/sessions/${encodeURIComponent(sessionId)}/interactive`, {
+      method: "POST"
+    });
+  }
+  async sendPrompt(sessionId, prompt, clientId, seq, signal) {
+    const input = `${prompt.replaceAll(/\r?\n/g, " ")}\r`;
+    return this.requestData(
+      `/api/v1/sessions/${encodeURIComponent(sessionId)}/input`,
+      {
+        method: "POST",
+        body: {
+          input,
+          useMux: true,
+          clientId,
+          seq,
+          wait: true,
+          waitTimeout: this.waitTimeoutMs
+        },
+        signal
+      }
+    );
+  }
+  async sendInput(sessionId, input, raw = false) {
+    const deliveredInput = raw ? input : `${input.replaceAll(/\r?\n/g, " ")}${input.endsWith("\r") ? "" : "\r"}`;
+    await this.request(`/api/v1/sessions/${encodeURIComponent(sessionId)}/input`, {
+      method: "POST",
+      body: {
+        input: deliveredInput,
+        useMux: !raw,
+        clientId: "hosted-agents-connector",
+        seq: ++this.inputSequence
+      }
+    });
+  }
+  async resize(sessionId, cols, rows) {
+    await this.request(`/api/v1/sessions/${encodeURIComponent(sessionId)}/resize`, {
+      method: "POST",
+      body: { cols, rows, viewportType: "desktop" }
+    });
+  }
+  async waitForCompletion(sessionId, signal) {
+    while (true) {
+      const data = await this.requestData(
+        `/api/v1/sessions/${encodeURIComponent(sessionId)}/wait?until=stop,exit&timeout=${this.waitTimeoutMs}`,
+        { signal }
+      );
+      if (!data.wait?.timedOut) return data.wait;
+    }
+  }
+  async lastResponse(sessionId, signal) {
+    return this.requestData(
+      `/api/v1/sessions/${encodeURIComponent(sessionId)}/last-response`,
+      { signal }
+    );
+  }
+  async deleteSession(sessionId, signal) {
+    await this.request(
+      `/api/v1/sessions/${encodeURIComponent(sessionId)}`,
+      { method: "DELETE", signal }
+    );
+  }
+  subscribeEvents(onEvent) {
+    const abort = new AbortController();
+    void this.readEvents(abort.signal, onEvent);
+    return () => abort.abort();
+  }
+  async readEvents(signal, onEvent) {
+    const response = await this.fetchImpl(`${this.baseUrl}/api/v1/events`, {
+      headers: { ...this.headers, accept: "text/event-stream" },
+      signal
+    }).catch(() => void 0);
+    if (!response?.ok || !response.body) return;
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+    try {
+      while (!signal.aborted) {
+        const result = await reader.read();
+        if (result.done) return;
+        buffer += decoder.decode(result.value, { stream: true });
+        let boundary = sseBoundary(buffer);
+        while (boundary) {
+          const raw = buffer.slice(0, boundary.index);
+          buffer = buffer.slice(boundary.index + boundary.length);
+          boundary = sseBoundary(buffer);
+          const data = raw.split(/\r?\n/).filter((line) => line.startsWith("data:")).map((line) => line.slice(5).trimStart()).join("\n");
+          if (!data) continue;
+          try {
+            const parsed = JSON.parse(data);
+            const nestedSession = isRecord(parsed.session) ? parsed.session : void 0;
+            const nestedData = isRecord(parsed.data) ? parsed.data : void 0;
+            const sessionId = String(
+              parsed.sessionId ?? parsed.session_id ?? nestedSession?.id ?? nestedData?.sessionId ?? nestedData?.session_id ?? ""
+            );
+            if (!sessionId) continue;
+            onEvent({
+              sessionId,
+              type: String(
+                parsed.type ?? parsed.event ?? raw.split(/\r?\n/).find((line) => line.startsWith("event:"))?.slice("event:".length).trim() ?? ""
+              ).toLowerCase(),
+              data: parsed.data ?? parsed.output ?? parsed.text,
+              createdAt: providerTimestamp(parsed.createdAt ?? parsed.created_at)
+            });
+          } catch {
+          }
+        }
+      }
+    } catch {
+    } finally {
+      reader.releaseLock();
+    }
+  }
+  async requestData(path, options = {}) {
+    const envelope = await this.request(path, options);
+    if (envelope.data === void 0) {
+      throw new CodemanApiError(200, "Codeman response did not include data");
+    }
+    return envelope.data;
+  }
+  async request(path, options = {}) {
+    const response = await this.fetchImpl(`${this.baseUrl}${path}`, {
+      method: options.method ?? "GET",
+      headers: {
+        ...this.headers,
+        ...options.body === void 0 ? {} : { "content-type": "application/json" }
+      },
+      body: options.body === void 0 ? void 0 : JSON.stringify(options.body),
+      signal: options.signal
+    });
+    const text = await response.text();
+    let envelope;
+    try {
+      envelope = JSON.parse(text);
+    } catch {
+      throw new CodemanApiError(response.status, text || response.statusText);
+    }
+    if (!response.ok || envelope.success === false) {
+      throw new CodemanApiError(
+        response.status,
+        envelope.error ?? `Codeman request failed with HTTP ${response.status}`,
+        envelope.errorCode
+      );
+    }
+    return envelope;
+  }
+};
+var CodemanWorkerRuntime = class {
+  client;
+  nodeId;
+  instanceId;
+  workspaces;
+  workspacePolicy;
+  send;
+  mode;
+  agentProfiles;
+  cursorCommand;
+  claudeCommand;
+  activeJobs = /* @__PURE__ */ new Map();
+  constructor(options) {
+    this.client = options.client;
+    this.nodeId = options.nodeId;
+    this.instanceId = options.instanceId ?? options.nodeId;
+    this.workspaces = options.workspaces;
+    this.workspacePolicy = options.workspacePolicy;
+    this.send = options.send;
+    this.mode = options.mode ?? "claude";
+    this.agentProfiles = options.agentProfiles?.map((agent) => ({ ...agent })) ?? [];
+    this.cursorCommand = options.cursorCommand;
+    this.claudeCommand = options.claudeCommand;
+  }
+  async handle(message) {
+    if (message.type === "job.assign") {
+      await this.assign(message.job);
+      return;
+    }
+    if (message.type === "job.cancel") {
+      await this.cancel(message.jobId);
+    }
+  }
+  async handleConnectorRequest(request) {
+    if (request.instanceId !== this.instanceId) {
+      throw new Error("Connector instance authorization failed");
+    }
+    const payload = request.payload ?? {};
+    switch (request.operation) {
+      case "status":
+        return this.client.status();
+      case "capabilities": {
+        const status = await this.client.status();
+        const codemanAgents = [
+          {
+            id: this.mode,
+            name: this.mode === "claude" ? "Claude Code" : this.mode,
+            mode: this.mode,
+            ready: true
+          },
+          ...status.agents ?? [],
+          ...status.capabilities ?? []
+        ];
+        return [
+          ...codemanAgents,
+          ...this.agentProfiles.filter(
+            (agent) => !codemanAgents.some(
+              (candidate) => (typeof candidate === "string" ? candidate : candidate.id) === agent.id
+            )
+          )
+        ];
+      }
+      case "workspaces":
+        return this.workspaces;
+      case "workspaces.suggest":
+        return this.suggestWorkspacePaths(typeof payload.prefix === "string" ? payload.prefix : "");
+      case "sessions.list":
+        return this.client.listSessions(true);
+      case "sessions.create": {
+        const workspace = typeof payload.workspaceId === "string" ? this.resolveWorkspace(payload.workspaceId) : this.resolveWorkspacePath(requiredString(payload.workspacePath, "workspacePath"));
+        const agent = payload.agent;
+        if (!isAgentProfile(agent)) throw new Error("Invalid connector agent");
+        const session = await this.client.createSession({
+          workingDir: workspace.canonicalPath,
+          mode: agent.mode,
+          name: typeof payload.title === "string" ? payload.title : `${agent.name} \xB7 ${workspace.name}`
+        });
+        await this.client.startInteractive(session.id);
+        const providerCommand = agent.id === "cursor-agent" ? this.cursorCommand : agent.id === "claude-code" ? this.claudeCommand : void 0;
+        if (providerCommand) {
+          await this.client.sendInput(session.id, `${providerCommand}\r`, true);
+        }
+        return {
+          ...session,
+          workspaceId: workspace.id,
+          mode: agent.mode
+        };
+      }
+      case "sessions.input":
+        await this.client.sendInput(
+          requiredString(payload.sessionId, "sessionId"),
+          requiredInput(payload.input, "input"),
+          payload.raw === true
+        );
+        return void 0;
+      case "sessions.resize":
+        await this.client.resize(
+          requiredString(payload.sessionId, "sessionId"),
+          requiredInteger(payload.cols, "cols"),
+          requiredInteger(payload.rows, "rows")
+        );
+        return void 0;
+      case "sessions.stop":
+        await this.client.deleteSession(requiredString(payload.sessionId, "sessionId"));
+        return void 0;
+    }
+  }
+  startEventForwarding() {
+    return this.client.subscribeEvents((event) => {
+      const mapped = this.toSessionEvent(event);
+      if (!mapped) return;
+      void this.send({
+        type: "codeman.session.event",
+        instanceId: this.instanceId,
+        event: mapped
+      }).catch(() => void 0);
+    });
+  }
+  async assign(job) {
+    if (job.provider !== "codeman") {
+      throw new Error(`Codeman runtime cannot execute provider: ${job.provider}`);
+    }
+    if (this.activeJobs.has(job.id)) return;
+    const workspace = this.resolveWorkspace(job.workspaceId);
+    const abortController = new AbortController();
+    const session = await this.client.createSession({
+      workingDir: workspace.canonicalPath,
+      mode: this.mode,
+      name: `hosted-${this.nodeId}-${job.id}`
+    });
+    this.activeJobs.set(job.id, { sessionId: session.id, abortController });
+    try {
+      await this.send({
+        type: "job.accept",
+        jobId: job.id,
+        idempotencyKey: job.idempotencyKey
+      });
+      await this.send({ type: "job.event", jobId: job.id, event: "started" });
+      await this.client.startInteractive(session.id);
+      const input = await this.client.sendPrompt(
+        session.id,
+        job.prompt,
+        `hosted-agents-${this.nodeId}`,
+        1,
+        abortController.signal
+      );
+      if (input.wait?.timedOut || !input.wait) {
+        await this.client.waitForCompletion(session.id, abortController.signal);
+      }
+      const response = await this.readResponse(session.id, abortController.signal);
+      await this.send({
+        type: "job.event",
+        jobId: job.id,
+        event: "completed",
+        data: response.text
+      });
+    } catch (error) {
+      if (abortController.signal.aborted) {
+        await this.send({ type: "job.event", jobId: job.id, event: "cancelled" });
+      } else {
+        await this.send({
+          type: "job.event",
+          jobId: job.id,
+          event: "failed",
+          data: error instanceof Error ? error.message : "Codeman job failed"
+        });
+      }
+    } finally {
+      this.activeJobs.delete(job.id);
+    }
+  }
+  async cancel(jobId) {
+    const active = this.activeJobs.get(jobId);
+    if (!active) return;
+    active.abortController.abort();
+    await this.client.deleteSession(active.sessionId);
+  }
+  async readResponse(sessionId, signal) {
+    let response = await this.client.lastResponse(sessionId, signal);
+    for (let attempt = 0; attempt < 10 && !response.text.trim(); attempt += 1) {
+      await delay(250, signal);
+      response = await this.client.lastResponse(sessionId, signal);
+    }
+    return response;
+  }
+  resolveWorkspace(workspaceId) {
+    const workspace = this.workspaces.find((candidate) => candidate.id === workspaceId);
+    if (!workspace) throw new Error(`Unknown workspace: ${workspaceId}`);
+    return this.validateWorkspace(workspace);
+  }
+  async suggestWorkspacePaths(prefix) {
+    const input = prefix.trim();
+    if (!input && this.workspacePolicy.mode === "folders") {
+      return this.workspacePolicy.roots.slice(0, 50).map((path) => ({ path: resolve(path), name: basename(path) || path }));
+    }
+    const trailingSeparator = /[\\/]/.test(input.at(-1) ?? "");
+    const basePath = input ? trailingSeparator ? input : dirname(input) : process.cwd();
+    const fragment = input && !trailingSeparator ? basename(input).toLowerCase() : "";
+    const directory = resolve(basePath);
+    if (!isAllowedPath(directory, this.workspacePolicy)) return [];
+    let entries;
+    try {
+      entries = await readdir(directory, { withFileTypes: true });
+    } catch (error) {
+      if (isFileSystemError(error, "ENOENT", "ENOTDIR")) return [];
+      throw error;
+    }
+    const suggestions = [];
+    for (const entry of entries) {
+      if (!entry.isDirectory() || entry.isSymbolicLink()) continue;
+      if (fragment && !entry.name.toLowerCase().startsWith(fragment)) continue;
+      const candidate = join(directory, entry.name);
+      let canonicalCandidate;
+      try {
+        canonicalCandidate = await realpath(candidate);
+      } catch (error) {
+        if (isFileSystemError(error, "ENOENT", "ELOOP")) continue;
+        throw error;
+      }
+      if (!isAllowedPath(canonicalCandidate, this.workspacePolicy)) continue;
+      suggestions.push({ path: canonicalCandidate, name: entry.name });
+      if (suggestions.length >= 50) break;
+    }
+    return suggestions.sort((left, right) => left.name.localeCompare(right.name));
+  }
+  resolveWorkspacePath(workspacePath) {
+    const existing = this.workspaces.find(
+      (candidate) => candidate.canonicalPath === workspacePath
+    );
+    if (existing) return this.validateWorkspace(existing);
+    if (!isAllowedPath(workspacePath, this.workspacePolicy)) {
+      throw new Error(`Workspace is outside the worker policy: ${workspacePath}`);
+    }
+    return {
+      id: workspacePath,
+      name: workspacePath.split(/[\\/]/).filter(Boolean).at(-1) ?? workspacePath,
+      canonicalPath: workspacePath,
+      health: "ready",
+      providers: { codeman: "ready" }
+    };
+  }
+  validateWorkspace(workspace) {
+    if (workspace.health !== "ready") {
+      throw new Error(`Workspace is not ready: ${workspace.id}`);
+    }
+    if (workspace.providers.codeman !== "ready") {
+      throw new Error("Codeman is not ready for the selected workspace");
+    }
+    if (!isAllowedPath(workspace.canonicalPath, this.workspacePolicy)) {
+      throw new Error(`Workspace is outside the worker policy: ${workspace.id}`);
+    }
+    return workspace;
+  }
+  toSessionEvent(event) {
+    const type = event.type;
+    let mapped;
+    if (type.includes("terminal") || type.includes("output")) mapped = "output";
+    else if (type.includes("permission") || type.includes("wait")) mapped = "waiting";
+    else if (type.includes("idle")) mapped = "idle";
+    else if (type.includes("fail") || type.includes("error")) mapped = "failed";
+    else if (type.includes("complete")) mapped = "completed";
+    else if (type.includes("exit") || type.includes("delet") || type.includes("stop")) mapped = "stopped";
+    else if (type.includes("start") || type.includes("run")) mapped = "started";
+    else if (type.includes("create")) mapped = "created";
+    else return void 0;
+    return {
+      instanceId: this.instanceId,
+      sessionId: event.sessionId,
+      event: mapped,
+      ...event.data === void 0 ? {} : { data: typeof event.data === "string" ? event.data : JSON.stringify(event.data) },
+      createdAt: event.createdAt
+    };
+  }
+};
+function requiredString(value, field) {
+  if (typeof value !== "string" || !value.trim()) throw new Error(`${field} is required`);
+  return value;
+}
+function requiredInput(value, field) {
+  if (typeof value !== "string" || value.length === 0) throw new Error(`${field} is required`);
+  return value;
+}
+function requiredInteger(value, field) {
+  if (typeof value !== "number" || !Number.isInteger(value) || value < 1 || value > 500) {
+    throw new Error(`${field} must be an integer between 1 and 500`);
+  }
+  return value;
+}
+function isAgentProfile(value) {
+  if (!isRecord(value)) return false;
+  const modes = [
+    "claude",
+    "shell",
+    "opencode",
+    "codex",
+    "gemini",
+    "antigravity",
+    "pi",
+    "grok",
+    "deepseek"
+  ];
+  return typeof value.name === "string" && modes.includes(value.mode);
+}
+function isAllowedPath(path, policy) {
+  if (policy.mode === "system") return true;
+  const normalizedPath = normalizePath(path);
+  return policy.roots.some((root) => {
+    const normalizedRoot = normalizePath(root);
+    return !normalizedRoot || normalizedPath === normalizedRoot || normalizedPath.startsWith(`${normalizedRoot}/`);
+  });
+}
+function normalizePath(path) {
+  const segments = [];
+  for (const segment of path.replaceAll("\\", "/").split("/")) {
+    if (!segment || segment === ".") continue;
+    if (segment === "..") {
+      segments.pop();
+    } else {
+      segments.push(segment);
+    }
+  }
+  return segments.join("/").toLowerCase();
+}
+function isFileSystemError(error, ...codes) {
+  return typeof error === "object" && error !== null && "code" in error && codes.includes(String(error.code));
+}
+function delay(milliseconds, signal) {
+  return new Promise((resolve2, reject) => {
+    const timer = setTimeout(resolve2, milliseconds);
+    signal.addEventListener(
+      "abort",
+      () => {
+        clearTimeout(timer);
+        reject(signal.reason ?? new Error("Operation aborted"));
+      },
+      { once: true }
+    );
+  });
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function sseBoundary(value) {
+  const lineFeed = value.indexOf("\n\n");
+  const carriageReturn = value.indexOf("\r\n\r\n");
+  if (lineFeed < 0 && carriageReturn < 0) return void 0;
+  if (lineFeed < 0) return { index: carriageReturn, length: 4 };
+  if (carriageReturn < 0 || lineFeed < carriageReturn) {
+    return { index: lineFeed, length: 2 };
+  }
+  return { index: carriageReturn, length: 4 };
+}
+function providerTimestamp(value) {
+  if (typeof value === "string" && !Number.isNaN(Date.parse(value))) return value;
+  if (typeof value === "number" && Number.isFinite(value)) return new Date(value).toISOString();
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+
+// apps/node-agent/src/index.ts
+function validateConfig(config) {
+  if (!config.nodeId.trim()) {
+    throw new Error("nodeId is required");
+  }
+  const controlPlane = new URL(config.controlPlaneUrl);
+  const localHost = ["localhost", "127.0.0.1", "::1"].includes(controlPlane.hostname);
+  if (controlPlane.protocol !== "https:" && !localHost) {
+    throw new Error("controlPlaneUrl must use HTTPS outside local development");
+  }
+  return {
+    ...config,
+    capabilities: [...new Set(config.capabilities)]
+  };
+}
+
+// packages/protocol/src/index.ts
+var DEFAULT_PREVIEW_LEASE_MS = 15 * 6e4;
+function isCodemanConnectorRequest(value) {
+  return isRecord2(value) && value.type === "codeman.request" && isNonEmptyString(value.requestId) && isNonEmptyString(value.instanceId) && isCodemanConnectorOperation(value.operation) && (value.payload === void 0 || isRecord2(value.payload));
+}
+function validateCodemanConnectorRequest(value) {
+  if (!isCodemanConnectorRequest(value)) {
+    throw new TypeError("Invalid Codeman connector request");
+  }
+  return value;
+}
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isNonEmptyString(value) {
+  return typeof value === "string" && value.trim().length > 0;
+}
+function isCodemanConnectorOperation(value) {
+  return value === "status" || value === "capabilities" || value === "workspaces" || value === "workspaces.suggest" || value === "sessions.list" || value === "sessions.create" || value === "sessions.input" || value === "sessions.resize" || value === "sessions.stop";
+}
+
+// apps/node-agent/src/transport.ts
+var ControllerTransport = class {
+  config;
+  fetchImpl;
+  heartbeatIntervalMs;
+  reconnect;
+  reconnectDelayMs;
+  connectorInstanceId;
+  handledConnectorRequests = /* @__PURE__ */ new Set();
+  abortController = new AbortController();
+  heartbeatTimer;
+  constructor(options) {
+    this.config = options;
+    this.fetchImpl = options.fetchImpl ?? fetch;
+    this.heartbeatIntervalMs = options.heartbeatIntervalMs ?? 15e3;
+    this.reconnect = options.reconnect ?? false;
+    this.reconnectDelayMs = options.reconnectDelayMs ?? 1e3;
+    this.connectorInstanceId = options.connectorInstanceId;
+  }
+  async start(handle, connectorHandle) {
+    await this.register();
+    this.heartbeatTimer = setInterval(() => {
+      void this.sendHeartbeat();
+    }, this.heartbeatIntervalMs);
+    try {
+      do {
+        try {
+          const response = await this.fetchImpl(
+            `${this.baseUrl()}/api/workers/${encodeURIComponent(this.config.nodeId)}/connect`,
+            {
+              headers: this.headers(),
+              signal: this.abortController.signal
+            }
+          );
+          if (!response.ok || !response.body) {
+            throw new Error(`Controller connection failed with HTTP ${response.status}`);
+          }
+          await readServerSentEvents(
+            response.body,
+            handle,
+            this.abortController.signal,
+            (request) => this.handleConnectorRequest(request, connectorHandle)
+          );
+        } catch (error) {
+          if (!this.reconnect || this.abortController.signal.aborted) throw error;
+        }
+        if (!this.reconnect || this.abortController.signal.aborted) break;
+        await delay2(this.reconnectDelayMs, this.abortController.signal);
+      } while (!this.abortController.signal.aborted);
+    } finally {
+      this.stop();
+    }
+  }
+  stop() {
+    if (this.heartbeatTimer) clearInterval(this.heartbeatTimer);
+    this.heartbeatTimer = void 0;
+    this.abortController.abort();
+  }
+  async send(message) {
+    const response = await this.fetchImpl(
+      `${this.baseUrl()}/api/workers/${encodeURIComponent(this.config.nodeId)}/messages`,
+      {
+        method: "POST",
+        headers: { ...this.headers(), "content-type": "application/json" },
+        body: JSON.stringify(message),
+        signal: this.abortController.signal
+      }
+    );
+    if (!response.ok) throw new Error(`Controller message failed with HTTP ${response.status}`);
+  }
+  async handleConnectorRequest(request, connectorHandle) {
+    const response = {
+      type: "codeman.response",
+      requestId: request.requestId,
+      instanceId: request.instanceId,
+      success: false,
+      error: "Connector is not enabled",
+      errorCode: "connector_disabled"
+    };
+    try {
+      if (this.connectorInstanceId && request.instanceId !== this.connectorInstanceId) {
+        throw new Error("Connector instance authorization failed");
+      }
+      if (this.handledConnectorRequests.has(request.requestId)) {
+        throw new Error("Duplicate connector request");
+      }
+      this.handledConnectorRequests.add(request.requestId);
+      if (this.handledConnectorRequests.size > 1e3) {
+        const oldest = this.handledConnectorRequests.values().next().value;
+        if (typeof oldest === "string") this.handledConnectorRequests.delete(oldest);
+      }
+      if (!connectorHandle) throw new Error("Connector is not enabled");
+      response.success = true;
+      response.data = await connectorHandle(request);
+      delete response.error;
+      delete response.errorCode;
+    } catch (error) {
+      response.error = error instanceof Error ? error.message : "Connector request failed";
+      response.errorCode = "connector_request_failed";
+    }
+    await this.send(response);
+  }
+  async register() {
+    const registration = {
+      nodeId: this.config.nodeId,
+      name: this.config.name,
+      platform: this.config.platform,
+      capabilities: this.config.capabilities,
+      labels: this.config.labels,
+      workspacePolicy: this.config.workspacePolicy,
+      workspaces: this.config.workspaces
+    };
+    const response = await this.fetchImpl(`${this.baseUrl()}/api/workers`, {
+      method: "POST",
+      headers: { ...this.headers(), "content-type": "application/json" },
+      body: JSON.stringify(registration),
+      signal: this.abortController.signal
+    });
+    if (!response.ok) throw new Error(`Controller enrollment failed with HTTP ${response.status}`);
+  }
+  async sendHeartbeat() {
+    await this.send({
+      type: "heartbeat",
+      nodeId: this.config.nodeId,
+      sentAt: (/* @__PURE__ */ new Date()).toISOString(),
+      capabilities: this.config.capabilities
+    });
+  }
+  baseUrl() {
+    return this.config.controlPlaneUrl.endsWith("/") ? this.config.controlPlaneUrl.slice(0, -1) : this.config.controlPlaneUrl;
+  }
+  headers() {
+    return this.config.authToken ? { accept: "text/event-stream, application/json", authorization: `Bearer ${this.config.authToken}` } : { accept: "text/event-stream, application/json" };
+  }
+};
+async function readServerSentEvents(body, handle, signal, handleConnectorRequest) {
+  const reader = body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = "";
+  while (!signal.aborted) {
+    const result = await reader.read();
+    if (result.done) return;
+    buffer += decoder.decode(result.value, { stream: true });
+    let boundary = sseBoundary2(buffer);
+    while (boundary) {
+      const event = buffer.slice(0, boundary.index);
+      buffer = buffer.slice(boundary.index + boundary.length);
+      boundary = sseBoundary2(buffer);
+      const data = event.split(/\r?\n/).filter((line) => line.startsWith("data:")).map((line) => line.slice(5).trimStart()).join("\n");
+      if (!data) continue;
+      const parsed = JSON.parse(data);
+      if (parsed.type === "codeman.request") {
+        await handleConnectorRequest(validateCodemanConnectorRequest(parsed));
+      } else if (typeof parsed.type === "string") {
+        await handle(parsed);
+      }
+    }
+  }
+}
+function delay2(milliseconds, signal) {
+  return new Promise((resolve2, reject) => {
+    const timer = setTimeout(resolve2, milliseconds);
+    signal.addEventListener("abort", () => {
+      clearTimeout(timer);
+      reject(signal.reason ?? new Error("Operation aborted"));
+    }, { once: true });
+  });
+}
+function sseBoundary2(value) {
+  const lineFeed = value.indexOf("\n\n");
+  const carriageReturn = value.indexOf("\r\n\r\n");
+  if (lineFeed < 0 && carriageReturn < 0) return void 0;
+  if (lineFeed < 0) return { index: carriageReturn, length: 4 };
+  if (carriageReturn < 0 || lineFeed < carriageReturn) {
+    return { index: lineFeed, length: 2 };
+  }
+  return { index: carriageReturn, length: 4 };
+}
+
+// apps/node-agent/src/main.ts
+function required(name) {
+  const value = process.env[name]?.trim();
+  if (!value) throw new Error(`${name} is required`);
+  return value;
+}
+function parseWorkspaces() {
+  const raw = process.env.HOSTED_AGENTS_WORKSPACES ?? "[]";
+  const value = JSON.parse(raw);
+  if (!Array.isArray(value)) throw new Error("HOSTED_AGENTS_WORKSPACES must be a JSON array");
+  return value.map((workspace) => ({
+    ...workspace,
+    id: `ws_${createHash("sha256").update(workspace.canonicalPath).digest("hex").slice(0, 20)}`
+  }));
+}
+function parsePolicy() {
+  const mode2 = process.env.HOSTED_AGENTS_WORKSPACE_MODE === "system" ? "system" : "folders";
+  const roots = (process.env.HOSTED_AGENTS_WORKSPACE_ROOTS ?? "").split(";").map((root) => root.trim()).filter(Boolean);
+  return { mode: mode2, roots };
+}
+function platform() {
+  if (process.platform === "darwin") return "macos";
+  if (process.platform === "win32") return "windows";
+  return "linux";
+}
+function commandAvailable(commandName) {
+  const result = process.platform === "win32" ? spawnSync("where.exe", [commandName], { encoding: "utf8", stdio: "pipe" }) : spawnSync("sh", ["-lc", `command -v ${commandName}`], { encoding: "utf8", stdio: "pipe" });
+  return result.status === 0 && Boolean(result.stdout?.trim());
+}
+function detectCommand(commandNames) {
+  for (const commandName of commandNames) {
+    if (commandAvailable(commandName)) return commandName;
+  }
+  for (const commandName of commandNames) {
+    const installedPath = join2(homedir(), ".local", "bin", commandName);
+    if (existsSync(installedPath)) return installedPath;
+  }
+  return void 0;
+}
+function isCursorAuthenticated(commandName) {
+  const result = spawnSync(commandName, ["status"], {
+    encoding: "utf8",
+    stdio: "pipe",
+    timeout: 5e3
+  });
+  const output = `${result.stdout ?? ""}
+${result.stderr ?? ""}`;
+  return result.status === 0 && !/not logged in|login required|unauthenticated/i.test(output);
+}
+function detectAgentProfiles(providers) {
+  return [
+    ...providers.cursor ? [{
+      id: "cursor-agent",
+      name: "Cursor Agent",
+      mode: "shell",
+      ready: providers.cursor.ready
+    }] : [],
+    ...providers.claude ? [{
+      id: "claude-code",
+      name: "Claude Code",
+      mode: "shell",
+      ready: providers.claude.ready
+    }] : []
+  ];
+}
+function mode() {
+  const selected = process.env.HOSTED_AGENTS_CODEMAN_MODE ?? "claude";
+  const modes = [
+    "claude",
+    "shell",
+    "opencode",
+    "codex",
+    "gemini",
+    "antigravity",
+    "pi",
+    "grok",
+    "deepseek"
+  ];
+  if (!modes.includes(selected)) {
+    throw new Error(`Unsupported HOSTED_AGENTS_CODEMAN_MODE: ${selected}`);
+  }
+  return selected;
+}
+async function runWorker() {
+  const cursorCommand = detectCommand(["agent", "cursor-agent"]);
+  const claudeCommand = detectCommand(["claude"]);
+  const providers = {
+    ...cursorCommand ? { cursor: { command: cursorCommand, ready: isCursorAuthenticated(cursorCommand) } } : {},
+    ...claudeCommand ? { claude: { command: claudeCommand, ready: true } } : {}
+  };
+  const agentProfiles = detectAgentProfiles(providers);
+  const workspaces = parseWorkspaces().map((workspace) => ({
+    ...workspace,
+    providers: {
+      ...workspace.providers,
+      cursor: !providers.cursor ? "missing" : providers.cursor.ready ? "ready" : "unauthenticated",
+      claude: !providers.claude ? "missing" : "ready"
+    }
+  }));
+  const config = validateConfig({
+    nodeId: required("HOSTED_AGENTS_NODE_ID"),
+    name: process.env.HOSTED_AGENTS_NODE_NAME ?? "Hosted Agents Worker",
+    platform: platform(),
+    capabilities: ["codeman", ...agentProfiles.length > 0 ? ["cursor-worker"] : []],
+    workspacePolicy: parsePolicy(),
+    workspaces,
+    controlPlaneUrl: required("HOSTED_AGENTS_CONTROLLER_URL"),
+    authToken: process.env.HOSTED_AGENTS_AUTH_TOKEN
+  });
+  const instanceId = process.env.CODEMAN_INSTANCE_ID ?? config.nodeId;
+  const transport = new ControllerTransport({
+    ...config,
+    connectorInstanceId: instanceId,
+    reconnect: true
+  });
+  const codeman = new CodemanClient({
+    baseUrl: process.env.CODEMAN_URL ?? "http://127.0.0.1:3000",
+    username: process.env.CODEMAN_USERNAME,
+    password: process.env.CODEMAN_PASSWORD
+  });
+  const runtime = new CodemanWorkerRuntime({
+    client: codeman,
+    nodeId: config.nodeId,
+    instanceId,
+    workspaces,
+    workspacePolicy: config.workspacePolicy ?? { mode: "folders", roots: [] },
+    send: (message) => transport.send(message),
+    mode: mode(),
+    agentProfiles,
+    cursorCommand,
+    claudeCommand
+  });
+  const stopEventForwarding = runtime.startEventForwarding();
+  process.once("SIGINT", () => transport.stop());
+  process.once("SIGTERM", () => transport.stop());
+  try {
+    await transport.start(
+      (message) => runtime.handle(message),
+      (request) => runtime.handleConnectorRequest(request)
+    );
+  } finally {
+    stopEventForwarding();
+  }
+}
+if (process.argv[1]?.endsWith("/main.ts") || process.argv[1]?.endsWith("\\main.ts") || process.argv[1]?.endsWith("/worker.mjs") || process.argv[1]?.endsWith("\\worker.mjs")) {
+  runWorker().catch((error) => {
+    console.error(error instanceof Error ? error.message : error);
+    process.exitCode = 1;
+  });
+}
+export {
+  runWorker
+};