agent-ws 1.0.0

package/dist/agent.js

@@ -0,0 +1,760 @@
+// src/server/websocket.ts
+import { WebSocketServer, WebSocket } from "ws";
+
+// src/process/claude-runner.ts
+import { spawn } from "node:child_process";
+import { mkdirSync } from "node:fs";
+import { resolve } from "node:path";
+import { tmpdir } from "node:os";
+import { createInterface } from "node:readline";
+var DEFAULT_TIMEOUT_MS = 5 * 60 * 1e3;
+var ClaudeRunner = class {
+  process = null;
+  timeout = null;
+  disposed = false;
+  killed = false;
+  claudePath;
+  timeoutMs;
+  log;
+  sessionDir;
+  constructor(options) {
+    this.claudePath = options.claudePath ?? "claude";
+    this.timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    this.log = options.logger;
+    this.sessionDir = options.sessionDir ?? "agent-ws-sessions";
+  }
+  get isRunning() {
+    return this.process !== null;
+  }
+  run(options, handlers) {
+    if (this.disposed) {
+      handlers.onError("Runner has been disposed", options.requestId);
+      return;
+    }
+    this.kill();
+    const { prompt, model, systemPrompt, projectId, requestId, thinkingTokens } = options;
+    const args = [
+      "--print",
+      "--output-format",
+      "stream-json",
+      "--max-turns",
+      "1",
+      // Single-turn text output, no agentic loops
+      "--tools",
+      ""
+      // Disable tool use — we only want generated text
+    ];
+    if (projectId) {
+      args.push("--continue");
+    }
+    if (model) {
+      args.push("--model", model);
+    }
+    if (systemPrompt) {
+      args.push("--append-system-prompt", systemPrompt);
+    }
+    args.push("-");
+    this.log.info({ requestId, model, promptLength: prompt.length }, "Spawning Claude process");
+    this.killed = false;
+    let cwd;
+    if (projectId) {
+      const base = resolve(tmpdir(), this.sessionDir);
+      cwd = resolve(base, projectId);
+      if (!cwd.startsWith(base + "/") && cwd !== base) {
+        handlers.onError("Invalid projectId", requestId);
+        return;
+      }
+      mkdirSync(cwd, { recursive: true });
+    }
+    try {
+      const ALLOWED_ENV_KEYS = [
+        "PATH",
+        "HOME",
+        "USER",
+        "SHELL",
+        "TERM",
+        "LANG",
+        "LC_ALL",
+        "ANTHROPIC_API_KEY",
+        "NODE_PATH",
+        "XDG_CONFIG_HOME"
+      ];
+      const env = {};
+      if (thinkingTokens !== void 0) {
+        env["MAX_THINKING_TOKENS"] = String(thinkingTokens);
+      }
+      for (const key of ALLOWED_ENV_KEYS) {
+        if (process.env[key]) env[key] = process.env[key];
+      }
+      this.process = spawn(this.claudePath, args, {
+        stdio: ["pipe", "pipe", "pipe"],
+        cwd,
+        env
+      });
+    } catch (err) {
+      const message = err instanceof Error ? err.message : "Failed to start Claude";
+      this.log.error({ err, requestId }, "Failed to spawn Claude process");
+      handlers.onError(message, requestId);
+      return;
+    }
+    this.log.debug({ pid: this.process.pid, requestId }, "Claude process spawned");
+    if (this.process.stdin) {
+      this.process.stdin.write(prompt);
+      this.process.stdin.end();
+    }
+    let handlersDone = false;
+    const finish = (cb) => {
+      if (handlersDone) return;
+      handlersDone = true;
+      this.clearTimeout();
+      cb();
+    };
+    this.timeout = setTimeout(() => {
+      this.log.warn({ requestId }, "Claude process timed out");
+      this.kill();
+      finish(() => handlers.onError("Process timed out", requestId));
+    }, this.timeoutMs);
+    if (this.process.stdout) {
+      const rl = createInterface({ input: this.process.stdout });
+      rl.on("line", (line) => {
+        this.parseStreamLine(line, handlers, requestId);
+      });
+    }
+    if (this.process.stderr) {
+      const stderrRl = createInterface({ input: this.process.stderr });
+      stderrRl.on("line", (line) => {
+        if (line.trim()) {
+          this.log.warn({ requestId, stderr: line }, "Claude stderr");
+        }
+      });
+    }
+    this.process.on("exit", (exitCode, signal) => {
+      this.process = null;
+      if (this.killed) {
+        this.log.debug({ requestId }, "Claude process was killed");
+        return;
+      }
+      if (exitCode === 0) {
+        this.log.info({ requestId }, "Claude process completed successfully");
+        finish(() => handlers.onComplete(requestId));
+      } else {
+        const reason = exitCode !== null ? `Claude CLI exited with code ${exitCode}` : `Claude CLI killed by signal ${signal ?? "unknown"}`;
+        this.log.warn({ requestId, exitCode, signal }, reason);
+        finish(() => handlers.onError(reason, requestId));
+      }
+    });
+    this.process.on("error", (err) => {
+      this.process = null;
+      this.log.error({ err, requestId }, "Claude process error");
+      finish(() => handlers.onError(err.message, requestId));
+    });
+  }
+  /**
+   * Parse a single NDJSON line from Claude CLI's stream-json output.
+   *
+   * The stream-json format can emit several event types. We look for content
+   * in these known patterns (in priority order):
+   *
+   * 1. Raw Anthropic API event: { type: "content_block_delta", delta: { type: "text_delta"|"thinking_delta", text|thinking } }
+   * 2. Wrapped stream event:    { type: "stream_event", event: { type: "content_block_delta", ... } }
+   * 3. Complete assistant msg:   { type: "assistant", message: { content: [{ type: "text"|"thinking", text|thinking }] } }
+   */
+  parseStreamLine(line, handlers, requestId) {
+    if (!line.trim()) return;
+    try {
+      const event = JSON.parse(line);
+      if (event.type === "content_block_delta") {
+        if (event.delta?.type === "text_delta" && event.delta.text) {
+          handlers.onChunk(event.delta.text, requestId);
+        } else if (event.delta?.type === "thinking_delta" && event.delta.thinking) {
+          handlers.onChunk(event.delta.thinking, requestId, true);
+        }
+        return;
+      }
+      if (event.type === "stream_event" && event.event) {
+        const inner = event.event;
+        if (inner.type === "content_block_delta") {
+          if (inner.delta?.type === "text_delta" && inner.delta.text) {
+            handlers.onChunk(inner.delta.text, requestId);
+          } else if (inner.delta?.type === "thinking_delta" && inner.delta.thinking) {
+            handlers.onChunk(inner.delta.thinking, requestId, true);
+          }
+        }
+        return;
+      }
+      if (event.type === "assistant" && Array.isArray(event.message?.content)) {
+        for (const block of event.message.content) {
+          if (block.type === "text" && block.text) {
+            handlers.onChunk(block.text, requestId);
+          } else if (block.type === "thinking" && block.thinking) {
+            handlers.onChunk(block.thinking, requestId, true);
+          }
+        }
+        return;
+      }
+      if (event.type === "result") {
+        return;
+      }
+    } catch {
+    }
+  }
+  kill() {
+    this.clearTimeout();
+    if (this.process) {
+      this.log.debug({ pid: this.process.pid }, "Killing Claude process");
+      this.killed = true;
+      try {
+        this.process.kill();
+      } catch {
+      }
+      this.process = null;
+    }
+  }
+  dispose() {
+    this.disposed = true;
+    this.kill();
+  }
+  clearTimeout() {
+    if (this.timeout) {
+      clearTimeout(this.timeout);
+      this.timeout = null;
+    }
+  }
+};
+
+// src/process/codex-runner.ts
+import { spawn as spawn2 } from "node:child_process";
+import { mkdirSync as mkdirSync2 } from "node:fs";
+import { resolve as resolve2 } from "node:path";
+import { tmpdir as tmpdir2 } from "node:os";
+import { createInterface as createInterface2 } from "node:readline";
+var DEFAULT_TIMEOUT_MS2 = 5 * 60 * 1e3;
+var CodexRunner = class {
+  process = null;
+  timeout = null;
+  disposed = false;
+  killed = false;
+  codexPath;
+  timeoutMs;
+  log;
+  sessionDir;
+  constructor(options) {
+    this.codexPath = options.codexPath ?? "codex";
+    this.timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS2;
+    this.log = options.logger;
+    this.sessionDir = options.sessionDir ?? "agent-ws-sessions";
+  }
+  get isRunning() {
+    return this.process !== null;
+  }
+  run(options, handlers) {
+    if (this.disposed) {
+      handlers.onError("Runner has been disposed", options.requestId);
+      return;
+    }
+    this.kill();
+    const { prompt, model, systemPrompt, projectId, requestId } = options;
+    let fullPrompt = prompt;
+    if (systemPrompt) {
+      fullPrompt = `${systemPrompt}
+
+---
+
+${prompt}`;
+    }
+    const args = ["--json"];
+    if (model) {
+      args.push("--model", model);
+    }
+    args.push("-");
+    this.log.info({ requestId, model, promptLength: prompt.length }, "Spawning Codex process");
+    this.killed = false;
+    let cwd;
+    if (projectId) {
+      const base = resolve2(tmpdir2(), this.sessionDir);
+      cwd = resolve2(base, projectId);
+      if (!cwd.startsWith(base + "/") && cwd !== base) {
+        handlers.onError("Invalid projectId", requestId);
+        return;
+      }
+      mkdirSync2(cwd, { recursive: true });
+    }
+    const ALLOWED_ENV_KEYS = [
+      "PATH",
+      "HOME",
+      "USER",
+      "SHELL",
+      "TERM",
+      "LANG",
+      "LC_ALL",
+      "OPENAI_API_KEY",
+      "NODE_PATH",
+      "XDG_CONFIG_HOME"
+    ];
+    const env = {};
+    for (const key of ALLOWED_ENV_KEYS) {
+      if (process.env[key]) env[key] = process.env[key];
+    }
+    try {
+      this.process = spawn2(this.codexPath, args, {
+        stdio: ["pipe", "pipe", "pipe"],
+        cwd,
+        env
+      });
+    } catch (err) {
+      const message = err instanceof Error ? err.message : "Failed to start Codex";
+      this.log.error({ err, requestId }, "Failed to spawn Codex process");
+      handlers.onError(message, requestId);
+      return;
+    }
+    this.log.debug({ pid: this.process.pid, requestId }, "Codex process spawned");
+    if (this.process.stdin) {
+      this.process.stdin.write(fullPrompt);
+      this.process.stdin.end();
+    }
+    let handlersDone = false;
+    const finish = (cb) => {
+      if (handlersDone) return;
+      handlersDone = true;
+      this.clearTimeout();
+      cb();
+    };
+    this.timeout = setTimeout(() => {
+      this.log.warn({ requestId }, "Codex process timed out");
+      this.kill();
+      finish(() => handlers.onError("Process timed out", requestId));
+    }, this.timeoutMs);
+    if (this.process.stdout) {
+      const rl = createInterface2({ input: this.process.stdout });
+      rl.on("line", (line) => {
+        this.parseStreamLine(line, handlers, requestId);
+      });
+    }
+    if (this.process.stderr) {
+      const stderrRl = createInterface2({ input: this.process.stderr });
+      stderrRl.on("line", (line) => {
+        if (line.trim()) {
+          this.log.warn({ requestId, stderr: line }, "Codex stderr");
+        }
+      });
+    }
+    this.process.on("exit", (exitCode, signal) => {
+      this.process = null;
+      if (this.killed) {
+        this.log.debug({ requestId }, "Codex process was killed");
+        return;
+      }
+      if (exitCode === 0) {
+        this.log.info({ requestId }, "Codex process completed successfully");
+        finish(() => handlers.onComplete(requestId));
+      } else {
+        const reason = exitCode !== null ? `Codex CLI exited with code ${exitCode}` : `Codex CLI killed by signal ${signal ?? "unknown"}`;
+        this.log.warn({ requestId, exitCode, signal }, reason);
+        finish(() => handlers.onError(reason, requestId));
+      }
+    });
+    this.process.on("error", (err) => {
+      this.process = null;
+      this.log.error({ err, requestId }, "Codex process error");
+      finish(() => handlers.onError(err.message, requestId));
+    });
+  }
+  /**
+   * Parse JSONL output from Codex CLI.
+   * Looks for text content in response events.
+   */
+  parseStreamLine(line, handlers, requestId) {
+    if (!line.trim()) return;
+    try {
+      const event = JSON.parse(line);
+      if (event.type === "message" && event.role === "assistant") {
+        if (Array.isArray(event.content)) {
+          for (const block of event.content) {
+            if (block.type === "output_text" && block.text) {
+              handlers.onChunk(block.text, requestId);
+            } else if (block.type === "text" && block.text) {
+              handlers.onChunk(block.text, requestId);
+            }
+          }
+        } else if (typeof event.content === "string" && event.content) {
+          handlers.onChunk(event.content, requestId);
+        }
+        return;
+      }
+      if (event.type === "response.completed" || event.type === "item.completed") {
+        return;
+      }
+    } catch {
+    }
+  }
+  kill() {
+    this.clearTimeout();
+    if (this.process) {
+      this.log.debug({ pid: this.process.pid }, "Killing Codex process");
+      this.killed = true;
+      try {
+        this.process.kill();
+      } catch {
+      }
+      this.process = null;
+    }
+  }
+  dispose() {
+    this.disposed = true;
+    this.kill();
+  }
+  clearTimeout() {
+    if (this.timeout) {
+      clearTimeout(this.timeout);
+      this.timeout = null;
+    }
+  }
+};
+
+// src/server/protocol.ts
+var MAX_PROMPT_BYTES = 512 * 1024;
+var MAX_SYSTEM_PROMPT_BYTES = 64 * 1024;
+var MAX_PROJECT_ID_LENGTH = 128;
+var PROJECT_ID_PATTERN = /^[a-zA-Z0-9._-]+$/;
+function parseClientMessage(raw) {
+  let data;
+  try {
+    data = JSON.parse(raw);
+  } catch {
+    return { ok: false, error: "Invalid JSON" };
+  }
+  if (typeof data !== "object" || data === null || Array.isArray(data)) {
+    return { ok: false, error: "Message must be a JSON object" };
+  }
+  const obj = data;
+  const type = obj["type"];
+  if (typeof type !== "string") {
+    return { ok: false, error: "Missing or invalid 'type' field" };
+  }
+  switch (type) {
+    case "prompt": {
+      const prompt = obj["prompt"];
+      if (typeof prompt !== "string" || prompt.length === 0) {
+        return { ok: false, error: "Missing or empty 'prompt' field" };
+      }
+      if (new TextEncoder().encode(prompt).byteLength > MAX_PROMPT_BYTES) {
+        return { ok: false, error: `Prompt exceeds maximum size of ${MAX_PROMPT_BYTES} bytes` };
+      }
+      const requestId = obj["requestId"];
+      if (typeof requestId !== "string" || requestId.length === 0) {
+        return { ok: false, error: "Missing or empty 'requestId' field" };
+      }
+      const model = obj["model"];
+      const systemPrompt = obj["systemPrompt"];
+      const projectId = obj["projectId"];
+      const provider = obj["provider"];
+      const thinkingTokens = obj["thinkingTokens"];
+      if (typeof systemPrompt === "string" && new TextEncoder().encode(systemPrompt).byteLength > MAX_SYSTEM_PROMPT_BYTES) {
+        return { ok: false, error: `System prompt exceeds maximum size of ${MAX_SYSTEM_PROMPT_BYTES} bytes` };
+      }
+      if (typeof projectId === "string") {
+        if (projectId.length > MAX_PROJECT_ID_LENGTH) {
+          return { ok: false, error: `projectId exceeds maximum length of ${MAX_PROJECT_ID_LENGTH}` };
+        }
+        if (!PROJECT_ID_PATTERN.test(projectId)) {
+          return { ok: false, error: "projectId contains invalid characters (allowed: alphanumeric, hyphens, underscores, dots)" };
+        }
+      }
+      return {
+        ok: true,
+        message: {
+          type: "prompt",
+          prompt,
+          model: typeof model === "string" ? model : void 0,
+          systemPrompt: typeof systemPrompt === "string" ? systemPrompt : void 0,
+          projectId: typeof projectId === "string" ? projectId : void 0,
+          requestId,
+          provider: provider === "codex" ? "codex" : "claude",
+          thinkingTokens: typeof thinkingTokens === "number" && thinkingTokens >= 0 ? thinkingTokens : void 0
+        }
+      };
+    }
+    case "cancel": {
+      const requestId = obj["requestId"];
+      return {
+        ok: true,
+        message: {
+          type: "cancel",
+          requestId: typeof requestId === "string" ? requestId : void 0
+        }
+      };
+    }
+    default:
+      return { ok: false, error: `Unknown message type: ${String(type).slice(0, 50)}` };
+  }
+}
+function serializeMessage(message) {
+  return JSON.stringify(message);
+}
+
+// src/server/websocket.ts
+var HEARTBEAT_INTERVAL_MS = 3e4;
+var DEFAULT_MAX_PAYLOAD = 1024 * 1024;
+var AgentWebSocketServer = class {
+  wss = null;
+  heartbeatInterval = null;
+  connections = /* @__PURE__ */ new Map();
+  log;
+  options;
+  constructor(options) {
+    this.options = options;
+    this.log = options.logger;
+  }
+  start() {
+    return new Promise((resolve3, reject) => {
+      this.wss = new WebSocketServer({
+        port: this.options.port,
+        host: this.options.host,
+        maxPayload: this.options.maxPayload ?? DEFAULT_MAX_PAYLOAD
+      });
+      this.wss.on("listening", () => {
+        this.log.info({ port: this.options.port, host: this.options.host }, "WebSocket server started");
+        this.startHeartbeat();
+        resolve3();
+      });
+      this.wss.on("error", (err) => {
+        if (err.code === "EADDRINUSE") {
+          this.log.fatal({ port: this.options.port }, "Port already in use");
+        } else {
+          this.log.error({ err }, "WebSocket server error");
+        }
+        reject(err);
+      });
+      this.wss.on("connection", (ws, req) => this.handleConnection(ws, req));
+    });
+  }
+  stop() {
+    if (this.heartbeatInterval) {
+      clearInterval(this.heartbeatInterval);
+      this.heartbeatInterval = null;
+    }
+    for (const [ws, state] of this.connections) {
+      state.runner.dispose();
+      ws.terminate();
+    }
+    this.connections.clear();
+    if (this.wss) {
+      this.wss.close();
+      this.wss = null;
+    }
+    this.log.info("WebSocket server stopped");
+  }
+  handleConnection(ws, req) {
+    if (this.options.allowedOrigins && this.options.allowedOrigins.length > 0) {
+      const origin = req.headers.origin;
+      if (!origin || !this.options.allowedOrigins.includes(origin)) {
+        this.log.warn({ origin: origin ?? "(none)" }, "Rejected connection: origin not in allowlist");
+        ws.close(4003, "Origin not allowed");
+        return;
+      }
+    }
+    const clientIp = req.socket.remoteAddress;
+    this.log.info({ clientIp }, "Client connected");
+    const runner = this.createRunner();
+    const state = { runner, isAlive: true, activeRequestId: null };
+    this.connections.set(ws, state);
+    this.sendMessage(ws, {
+      type: "connected",
+      version: "1.0",
+      agent: this.options.agentName ?? "agent-ws"
+    });
+    ws.on("pong", () => {
+      state.isAlive = true;
+    });
+    ws.on("message", (data) => {
+      const raw = data.toString();
+      this.handleMessage(ws, state, raw);
+    });
+    ws.on("close", () => {
+      this.log.info({ clientIp }, "Client disconnected");
+      state.runner.dispose();
+      this.connections.delete(ws);
+    });
+    ws.on("error", (err) => {
+      this.log.error({ err, clientIp }, "WebSocket error");
+    });
+  }
+  handleMessage(ws, state, raw) {
+    const result = parseClientMessage(raw);
+    if (!result.ok) {
+      this.sendMessage(ws, { type: "error", message: result.error });
+      return;
+    }
+    const { message } = result;
+    switch (message.type) {
+      case "prompt":
+        this.handlePrompt(ws, state, message);
+        break;
+      case "cancel":
+        this.handleCancel(ws, state);
+        break;
+    }
+  }
+  handlePrompt(ws, state, message) {
+    if (state.activeRequestId !== null) {
+      this.sendMessage(ws, {
+        type: "error",
+        message: "Request already in progress",
+        requestId: message.requestId
+      });
+      return;
+    }
+    state.activeRequestId = message.requestId;
+    if (message.provider === "codex") {
+      if (!(state.runner instanceof CodexRunner)) {
+        try {
+          state.runner.dispose();
+        } catch {
+        }
+        state.runner = new CodexRunner({
+          timeoutMs: this.options.timeoutMs,
+          logger: this.log.child({ component: "codex-runner" }),
+          sessionDir: this.options.sessionDir
+        });
+      }
+    } else {
+      if (!(state.runner instanceof ClaudeRunner)) {
+        try {
+          state.runner.dispose();
+        } catch {
+        }
+        state.runner = this.createRunner();
+      }
+    }
+    const handlers = {
+      onChunk: (content, requestId, thinking) => {
+        try {
+          this.sendMessage(ws, { type: "chunk", content, requestId, ...thinking ? { thinking: true } : {} });
+        } catch (err) {
+          this.log.warn({ err, requestId }, "Error in onChunk handler");
+        }
+      },
+      onComplete: (requestId) => {
+        try {
+          state.activeRequestId = null;
+          this.sendMessage(ws, { type: "complete", requestId });
+        } catch (err) {
+          this.log.warn({ err, requestId }, "Error in onComplete handler");
+        }
+      },
+      onError: (errorMessage, requestId) => {
+        try {
+          state.activeRequestId = null;
+          this.sendMessage(ws, { type: "error", message: errorMessage, requestId });
+        } catch (err) {
+          this.log.warn({ err, requestId }, "Error in onError handler");
+        }
+      }
+    };
+    state.runner.run(
+      { prompt: message.prompt, model: message.model, systemPrompt: message.systemPrompt, projectId: message.projectId, requestId: message.requestId, thinkingTokens: message.thinkingTokens },
+      handlers
+    );
+  }
+  handleCancel(ws, state) {
+    state.runner.kill();
+    const requestId = state.activeRequestId;
+    state.activeRequestId = null;
+    this.log.info({ requestId }, "Request cancelled");
+  }
+  sendMessage(ws, message) {
+    if (ws.readyState === WebSocket.OPEN) {
+      ws.send(serializeMessage(message));
+    } else {
+      this.log.warn({ messageType: message.type, readyState: ws.readyState }, "Dropping message, WebSocket not OPEN");
+    }
+  }
+  createRunner() {
+    if (this.options.runnerFactory) {
+      return this.options.runnerFactory(this.log);
+    }
+    const runnerOptions = {
+      claudePath: this.options.claudePath,
+      timeoutMs: this.options.timeoutMs,
+      logger: this.log.child({ component: "runner" }),
+      sessionDir: this.options.sessionDir
+    };
+    return new ClaudeRunner(runnerOptions);
+  }
+  startHeartbeat() {
+    this.heartbeatInterval = setInterval(() => {
+      for (const [ws, state] of this.connections) {
+        if (!state.isAlive) {
+          this.log.debug("Terminating dead connection");
+          state.runner.dispose();
+          this.connections.delete(ws);
+          ws.terminate();
+          continue;
+        }
+        state.isAlive = false;
+        try {
+          ws.ping();
+        } catch {
+          this.log.debug("Ping failed, terminating connection");
+          state.runner.dispose();
+          this.connections.delete(ws);
+          ws.terminate();
+        }
+      }
+    }, HEARTBEAT_INTERVAL_MS);
+  }
+};
+
+// src/utils/logger.ts
+import pino from "pino";
+function createLogger(options = {}) {
+  const { level = "info", pretty = process.env["NODE_ENV"] !== "production" } = options;
+  if (pretty) {
+    try {
+      return pino({
+        level,
+        transport: {
+          target: "pino-pretty",
+          options: {
+            colorize: true,
+            translateTime: "HH:MM:ss",
+            ignore: "pid,hostname"
+          }
+        }
+      });
+    } catch {
+    }
+  }
+  return pino({ level });
+}
+
+// src/agent.ts
+var AgentWS = class {
+  server;
+  log;
+  constructor(options = {}) {
+    this.log = createLogger({ level: options.logLevel ?? "info" });
+    const serverOptions = {
+      port: options.port ?? 9999,
+      host: options.host ?? "localhost",
+      logger: this.log,
+      claudePath: options.claudePath,
+      timeoutMs: options.timeoutMs,
+      allowedOrigins: options.allowedOrigins,
+      runnerFactory: options.runnerFactory,
+      agentName: options.agentName,
+      sessionDir: options.sessionDir
+    };
+    this.server = new AgentWebSocketServer(serverOptions);
+  }
+  async start() {
+    await this.server.start();
+  }
+  stop() {
+    this.server.stop();
+  }
+};
+export {
+  AgentWS
+};
+//# sourceMappingURL=agent.js.map