@anusornneal/chat-relay 0.6.0

package/README.md

@@ -0,0 +1,230 @@
+# chat-relay
+
+Cloudflare Worker + Durable Objects relay that exposes one or more local Windows agents to ChatGPT through remote MCP.
+
+```
+ChatGPT / MCP client
+        |
+        | Streamable HTTP MCP
+        v
+Cloudflare Worker
+        |
+        +-- Registry Durable Object (users, agents, grants)
+        |
+        +-- Relay Durable Object per agent
+                    |
+                    | WebSocket
+                    v
+             Local Agent
+             - terminal
+             - files
+             - processes
+```
+
+The relay is generic and has no Devflow-specific logic.
+
+## Zero-checkout CLI
+
+End users do not need this repository. After the npm package is published, the normal command is:
+
+```bash
+npx @anusornneal/chat-relay@latest remote
+```
+
+First run starts a device-login flow, opens the browser, and shows a short code. The browser page signs in with a Chat Relay login/password; if that login does not exist yet, it creates the account. After approval the CLI receives scoped user-session and agent credentials, stores them outside the project, and connects the local agent.
+
+Subsequent runs reuse the local credentials:
+
+```bash
+npx @anusornneal/chat-relay@latest remote
+```
+
+Other commands:
+
+```bash
+npx @anusornneal/chat-relay@latest login
+npx @anusornneal/chat-relay@latest status
+npx @anusornneal/chat-relay@latest logout
+```
+
+On Windows the config defaults to `%LOCALAPPDATA%\chat-relay\config.json`. On macOS/Linux it uses `$XDG_CONFIG_HOME/chat-relay/config.json` or `~/.config/chat-relay/config.json`. Set `CHAT_RELAY_HOME` to override the location.
+
+Useful options:
+
+```bash
+chat-relay remote --root "C:\Users\you\Projects"
+chat-relay login --name "Work PC"
+chat-relay login --no-open
+```
+
+The published package locates its bundled local agent relative to the package itself, so commands work from any working directory. Existing repository users can still run `npm start`; legacy `.dev.vars` credentials are migrated once into the user-level config.
+
+## Authentication and multi-user model
+
+- Browser/device login uses a short-lived device code. Raw user or admin tokens are not typed into the CLI.
+- New accounts use a unique login plus password. Passwords are stored only as salted PBKDF2-SHA256 hashes.
+- Device start/approval requests and failed password attempts are rate-limited.
+- CLI user sessions are opaque random tokens stored server-side only as hashes and expire after 90 days.
+- Re-authentication revokes the previous CLI session when possible.
+- Each local machine has an independent `agentId` and agent token; agent tokens are stored server-side only as hashes.
+- Agent ownership is enforced before an existing machine identity can be reused, preventing shared users from rotating another owner's agent credential.
+- Grants map users to agents with scopes: `read`, `write`, `terminal`, `process`, or `*`.
+- Logging out revokes the local user session and the owning machine credential.
+- `ADMIN_TOKEN` remains separate and protects administration routes.
+- The existing legacy owner token remains supported so current ChatGPT MCP URLs continue to work during migration.
+
+ChatGPT MCP supports OAuth 2.1 authorization-code login with PKCE S256. OAuth access tokens are audience-bound to `/mcp`; `offline_access` issues rotating refresh tokens. Dynamic client registration and protected-resource/authorization-server discovery are exposed for compatible MCP clients. The legacy `/mcp?key=<USER_TOKEN>` flow remains supported during migration. Browser/device login is for the zero-checkout local CLI and creates the same registry user/agent model used by OAuth.
+
+## MCP tools
+
+Identity and agent routing:
+- `whoami`
+- `list_agents`
+- `ping_agent`
+- `get_config`
+- `get_recent_tool_calls`
+
+Filesystem:
+- `stat_path`
+- `list_directory`
+- `read_file`
+- `read_multiple_files`
+- `start_search`
+- `get_more_search_results`
+- `write_file`
+- `edit_block`
+- `create_directory`
+- `move_path`
+- `delete_path`
+
+Processes:
+- `list_processes`
+- `kill_process`
+
+Terminal:
+- `terminal_exec`
+- `terminal_start`
+- `terminal_start_shell`
+- `terminal_read`
+- `terminal_write`
+- `terminal_list`
+- `terminal_kill`
+
+Desktop-Commander-compatible aliases:
+- `start_process`
+- `read_process_output`
+- `interact_with_process`
+- `list_sessions`
+- `force_terminate`
+
+## Administration
+
+Administration is intentionally separate from MCP. Set the Cloudflare `ADMIN_TOKEN` secret, keep the same value in the local ignored `.dev.vars` on the administrator machine, and use:
+
+```
+npm run admin -- state
+npm run admin -- bootstrap default "Primary PC"
+npm run admin -- create-user "Alice"
+npm run admin -- create-agent "Work Laptop" work-laptop
+npm run admin -- grant <userId> <agentId> read,write,terminal,process
+npm run admin -- revoke <userId> <agentId>
+npm run admin -- enable-user <userId> false
+npm run admin -- enable-agent <agentId> false
+npm run admin -- rotate-user <userId>
+npm run admin -- rotate-agent <agentId>
+```
+
+Create and rotate commands return the new raw token once. Store it on the corresponding client/agent; the registry retains only its hash.
+
+The initial `bootstrap` migrates the legacy `CALLER_TOKEN` and `AGENT_TOKEN` secrets into an owner user and the default agent so an existing installation can upgrade without changing its current ChatGPT URL or local agent token.
+
+## Worker routes
+
+| Route | Authentication | Purpose |
+| --- | --- | --- |
+| `GET /health` | none | Worker health |
+| `GET /.well-known/oauth-protected-resource[/mcp]` | none | MCP protected-resource metadata |
+| `GET /.well-known/oauth-authorization-server` | none | OAuth authorization-server metadata |
+| `POST /register` | none | Dynamic registration for public PKCE clients |
+| `GET/POST /authorize` | login/password | OAuth authorization-code sign-in |
+| `POST /token` | public client + PKCE/refresh token | Access/refresh token exchange |
+| `POST /auth/device/start` | none | Start CLI device authorization |
+| `GET /device?user_code=<code>` | none | Browser sign-in/approval page |
+| `POST /auth/device/approve` | login/password + device code | Approve or create a user account |
+| `POST /auth/device/token` | device code | Exchange approved device code for session/agent credentials |
+| `GET /auth/me` | user Bearer token | Current user and permitted agents |
+| `POST /auth/session/revoke` | user Bearer token | Revoke only the current user session |
+| `POST /auth/logout` | user Bearer token | Revoke local session and owning agent credential |
+| `POST /mcp?key=<user token>` | user token | Streamable HTTP MCP |
+| `GET /agent?agentId=<id>` | agent Bearer token | Local agent WebSocket |
+| `GET /status?agentId=<id>` | user token | Agent online status |
+| `POST /relay?agentId=<id>` | user token | Direct JSON relay with scope checks |
+| `/admin/*` | admin Bearer token | User/agent/grant administration |
+
+## Runtime limits and controls
+
+- Relay request/response message: 64 KiB.
+- One-shot terminal command: max 20 seconds.
+- Persistent terminal sessions: up to 8 running sessions per local agent.
+- Terminal output buffer: bounded in memory; completed sessions retained for 30 minutes.
+- Filesystem reads/writes are bounded and restricted to configured `ALLOWED_ROOTS`.
+- Search skips common heavy directories such as `.git`, `node_modules`, `.gradle`, `.idea`, and `.wrangler`.
+- The agent blocks a small set of high-risk system-management commands. This is defense in depth, not a security sandbox.
+
+## Tests
+
+The legacy relay integration test remains available:
+
+```
+npm run dev:test
+python test/integration.py
+```
+
+The full MCP/multi-user smoke test expects a local Worker on port 8795 plus an attached local agent:
+
+```
+node test/multiuser-smoke.mjs
+```
+
+It verifies the MCP tool surface, agent routing, filesystem operations, search sessions, process listing, persistent terminals, scope enforcement, multi-agent selection, and token rotation.
+
+Device/browser login is covered by:
+
+```bash
+TEST_RELAY_URL=http://127.0.0.1:8796 npm run test:device-auth
+```
+
+OAuth discovery, DCR, PKCE, token exchange, refresh rotation, audience binding, MCP Bearer auth, and legacy-key compatibility are covered by:
+
+```bash
+TEST_RELAY_URL=http://127.0.0.1:8796 npm run test:oauth
+```
+
+After `npm pack`, the zero-checkout package smoke test installs and runs the tarball from a temporary directory:
+
+```bash
+CHAT_RELAY_TARBALL=<path-to-tgz> TEST_RELAY_URL=http://127.0.0.1:8796 npm run test:zero-checkout
+```
+
+The npm package is configured as `@anusornneal/chat-relay`. Publishing requires an authenticated npm account with access to that scope.
+
+## CI and npm publishing
+
+GitHub Actions runs package verification on Node 20 and Node 24. A separate integration job starts a local Worker and verifies device auth, OAuth, and the zero-checkout tarball flow.
+
+Before publishing locally:
+
+```bash
+npm run verify:publish
+```
+
+This checks the npm file set, CLI entrypoint, Worker dry-run build, and production dependency audit. The package whitelist excludes .dev.vars, Worker source, tests, and repository-only files.
+
+The repository also includes a Publish npm workflow for version tags or manual dispatch. It supports npm trusted publishing through GitHub OIDC and can also use an NPM_TOKEN repository secret when configured.
+
+The first registry publish still requires npm authorization for the @anusornneal scope. After publishing, verify the exact public UX from a clean directory:
+
+```bash
+npx @anusornneal/chat-relay@latest status
+npx @anusornneal/chat-relay@latest remote
+```

package/agent/file-manager.mjs

@@ -0,0 +1,265 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { randomUUID } from "node:crypto";
+
+const MAX_READ_BYTES = 256 * 1024;
+const MAX_WRITE_BYTES = 256 * 1024;
+const MAX_SEARCH_FILES = 5000;
+const SKIP_DIRS = new Set([".git", "node_modules", ".gradle", ".idea", ".wrangler"]);
+
+function splitRoots(spec) {
+  if (!spec) return [process.cwd()];
+  return spec.split(";").map((value) => value.trim()).filter(Boolean).map((value) => path.resolve(value));
+}
+
+function within(root, target) {
+  const relative = path.relative(root, target);
+  return relative === "" || (!relative.startsWith("..") && !path.isAbsolute(relative));
+}
+
+async function existingCanonical(target) {
+  return fs.realpath(target);
+}
+
+export class FileManager {
+  constructor(rootSpec) {
+    this.roots = splitRoots(rootSpec);
+    this.searches = new Map();
+  }
+
+  getRoots() {
+    return [...this.roots];
+  }
+
+  async #resolveExisting(input) {
+    const target = path.resolve(String(input));
+    const canonical = await existingCanonical(target);
+    for (const root of this.roots) {
+      const canonicalRoot = await existingCanonical(root).catch(() => path.resolve(root));
+      if (within(canonicalRoot, canonical)) return canonical;
+    }
+    throw new Error("path_not_allowed");
+  }
+
+  async #resolveTarget(input) {
+    const target = path.resolve(String(input));
+    const parent = await existingCanonical(path.dirname(target));
+    for (const root of this.roots) {
+      const canonicalRoot = await existingCanonical(root).catch(() => path.resolve(root));
+      if (within(canonicalRoot, parent)) return target;
+    }
+    throw new Error("path_not_allowed");
+  }
+
+  async stat(input) {
+    const target = await this.#resolveExisting(input);
+    const info = await fs.stat(target);
+    return {
+      path: target,
+      type: info.isDirectory() ? "directory" : info.isFile() ? "file" : "other",
+      size: info.size,
+      modifiedAt: info.mtime.toISOString(),
+      createdAt: info.birthtime.toISOString(),
+    };
+  }
+
+  async list(input, depth = 1) {
+    const target = await this.#resolveExisting(input);
+    const maxDepth = Math.min(Math.max(Number(depth) || 1, 0), 3);
+    const entries = [];
+    await this.#walkList(target, 0, maxDepth, entries);
+    return { path: target, entries };
+  }
+
+  async #walkList(current, level, maxDepth, output) {
+    const items = await fs.readdir(current, { withFileTypes: true });
+    items.sort((a, b) => a.name.localeCompare(b.name));
+    for (const item of items) {
+      const fullPath = path.join(current, item.name);
+      let size = null;
+      if (item.isFile()) size = (await fs.stat(fullPath)).size;
+      output.push({
+        path: fullPath,
+        name: item.name,
+        type: item.isDirectory() ? "directory" : item.isFile() ? "file" : "other",
+        size,
+      });
+      if (output.length >= 1000) return;
+      if (item.isDirectory() && level < maxDepth && !SKIP_DIRS.has(item.name)) {
+        await this.#walkList(fullPath, level + 1, maxDepth, output);
+        if (output.length >= 1000) return;
+      }
+    }
+  }
+
+  async read(input, offset = 0, length = 200) {
+    const target = await this.#resolveExisting(input);
+    const info = await fs.stat(target);
+    if (!info.isFile()) throw new Error("not_a_file");
+    if (info.size > MAX_READ_BYTES * 8) throw new Error("file_too_large");
+
+    const text = await fs.readFile(target, "utf8");
+    const lines = text.split(/\r?\n/);
+    const start = Math.max(Number(offset) || 0, 0);
+    const count = Math.min(Math.max(Number(length) || 200, 1), 1000);
+    return {
+      path: target,
+      offset: start,
+      length: Math.min(count, Math.max(lines.length - start, 0)),
+      totalLines: lines.length,
+      content: lines.slice(start, start + count).join("\n"),
+    };
+  }
+
+  async readMany(paths) {
+    if (!Array.isArray(paths) || paths.length === 0 || paths.length > 20) {
+      throw new Error("invalid_paths");
+    }
+    const files = [];
+    for (const input of paths) {
+      try {
+        files.push({ ok: true, ...(await this.read(input, 0, 1000)) });
+      } catch (error) {
+        files.push({ ok: false, path: String(input), error: error instanceof Error ? error.message : "read_failed" });
+      }
+    }
+    return { files };
+  }
+
+  async write(input, content, mode = "rewrite") {
+    if (typeof content !== "string" || Buffer.byteLength(content, "utf8") > MAX_WRITE_BYTES) {
+      throw new Error("content_too_large");
+    }
+    const target = await this.#resolveTarget(input);
+    if (mode === "append") await fs.appendFile(target, content, "utf8");
+    else if (mode === "rewrite") await fs.writeFile(target, content, "utf8");
+    else throw new Error("invalid_write_mode");
+    return this.stat(target);
+  }
+
+  async edit(input, oldText, newText, expectedReplacements = 1) {
+    if (typeof oldText !== "string" || oldText.length === 0 || typeof newText !== "string") {
+      throw new Error("invalid_edit");
+    }
+    const target = await this.#resolveExisting(input);
+    const text = await fs.readFile(target, "utf8");
+    const parts = text.split(oldText);
+    const matches = parts.length - 1;
+    const expected = Number(expectedReplacements) || 1;
+    if (matches !== expected) {
+      throw new Error(`replacement_count_mismatch:${matches}`);
+    }
+    const updated = parts.join(newText);
+    if (Buffer.byteLength(updated, "utf8") > MAX_WRITE_BYTES * 8) throw new Error("file_too_large");
+    await fs.writeFile(target, updated, "utf8");
+    return { path: target, replacements: matches };
+  }
+
+  async mkdir(input) {
+    const target = await this.#resolveTarget(input);
+    await fs.mkdir(target, { recursive: true });
+    return this.stat(target);
+  }
+
+  async move(source, destination) {
+    const from = await this.#resolveExisting(source);
+    const to = await this.#resolveTarget(destination);
+    await fs.rename(from, to);
+    return { from, to };
+  }
+
+  async remove(input, recursive = false) {
+    const target = await this.#resolveExisting(input);
+    if (this.roots.some((root) => path.resolve(root) === path.resolve(target))) {
+      throw new Error("cannot_delete_root");
+    }
+    const info = await fs.stat(target);
+    if (info.isDirectory()) await fs.rm(target, { recursive: Boolean(recursive), force: false });
+    else await fs.unlink(target);
+    return { ok: true, path: target };
+  }
+
+  async startSearch(input, pattern, searchType = "files", maxResults = 100) {
+    const target = await this.#resolveExisting(input);
+    if (typeof pattern !== "string" || pattern.length === 0 || pattern.length > 300) {
+      throw new Error("invalid_pattern");
+    }
+    if (!["files", "content"].includes(searchType)) throw new Error("invalid_search_type");
+
+    const sessionId = randomUUID();
+    const session = {
+      id: sessionId,
+      status: "RUNNING",
+      createdAt: Date.now(),
+      results: [],
+      error: null,
+    };
+    this.searches.set(sessionId, session);
+
+    try {
+      const limit = Math.min(Math.max(Number(maxResults) || 100, 1), 500);
+      const needle = pattern.toLowerCase();
+      let scanned = 0;
+
+      const walk = async (current) => {
+        if (session.results.length >= limit || scanned >= MAX_SEARCH_FILES) return;
+        const items = await fs.readdir(current, { withFileTypes: true }).catch(() => []);
+        for (const item of items) {
+          if (session.results.length >= limit || scanned >= MAX_SEARCH_FILES) break;
+          if (item.isDirectory() && SKIP_DIRS.has(item.name)) continue;
+          const fullPath = path.join(current, item.name);
+          scanned++;
+
+          if (searchType === "files" && item.name.toLowerCase().includes(needle)) {
+            session.results.push({ path: fullPath, name: item.name, type: item.isDirectory() ? "directory" : "file" });
+          } else if (searchType === "content" && item.isFile()) {
+            const info = await fs.stat(fullPath).catch(() => null);
+            if (info && info.size <= 1024 * 1024) {
+              const text = await fs.readFile(fullPath, "utf8").catch(() => null);
+              if (text != null) {
+                const index = text.toLowerCase().indexOf(needle);
+                if (index >= 0) {
+                  const before = text.slice(0, index);
+                  const line = before.split(/\r?\n/).length;
+                  session.results.push({ path: fullPath, line, preview: text.slice(index, index + 240) });
+                }
+              }
+            }
+          }
+
+          if (item.isDirectory()) await walk(fullPath);
+        }
+      };
+
+      await walk(target);
+      session.status = "COMPLETED";
+      session.scanned = scanned;
+    } catch (error) {
+      session.status = "ERROR";
+      session.error = error instanceof Error ? error.message : "search_failed";
+    }
+
+    return {
+      sessionId,
+      status: session.status,
+      totalResults: session.results.length,
+      scanned: session.scanned ?? 0,
+      error: session.error,
+    };
+  }
+
+  getSearchResults(sessionId, offset = 0, length = 50) {
+    const session = this.searches.get(String(sessionId));
+    if (!session) throw new Error("search_not_found");
+    const start = Math.max(Number(offset) || 0, 0);
+    const count = Math.min(Math.max(Number(length) || 50, 1), 100);
+    return {
+      sessionId: session.id,
+      status: session.status,
+      totalResults: session.results.length,
+      offset: start,
+      results: session.results.slice(start, start + count),
+      error: session.error,
+    };
+  }
+}

package/agent/local-agent.mjs

@@ -0,0 +1,157 @@
+import WebSocket from "ws";
+import { FileManager } from "./file-manager.mjs";
+import { ProcessManager } from "./process-manager.mjs";
+import { TerminalManager } from "./terminal-manager.mjs";
+
+const relayUrl = process.env.RELAY_URL;
+const agentToken = process.env.AGENT_TOKEN;
+const agentId = process.env.AGENT_ID || "default";
+const agentName = process.env.AGENT_NAME || agentId;
+const reconnectMs = Number(process.env.RECONNECT_MS ?? 2000);
+const terminalEnabled = process.env.TERMINAL_ENABLED === "1";
+const terminals = new TerminalManager();
+const files = new FileManager(process.env.ALLOWED_ROOTS);
+const processes = new ProcessManager();
+const recentCalls = [];
+
+if (!relayUrl || !agentToken) {
+  console.error("RELAY_URL and AGENT_TOKEN are required");
+  process.exit(1);
+}
+
+const wsUrl = relayUrl.replace(/^http/, "ws").replace(/\/$/, "") +
+  `/agent?agentId=${encodeURIComponent(agentId)}`;
+
+async function handlePayload(payload) {
+  if (!payload || typeof payload !== "object") return payload;
+
+  switch (payload.action) {
+    case "ping":
+      return { ok: true, action: "pong", at: new Date().toISOString(), agentId, agentName };
+
+    case "agent.config":
+      return processes.info({
+        agentId,
+        agentName,
+        terminalEnabled,
+        allowedRoots: files.getRoots(),
+        reconnectMs,
+      });
+    case "agent.recentCalls":
+      return recentCalls.slice(-(Math.min(Math.max(Number(payload.limit) || 50, 1), 100)));
+
+    case "fs.stat":
+      return files.stat(payload.path);
+    case "fs.list":
+      return files.list(payload.path, payload.depth);
+    case "fs.read":
+      return files.read(payload.path, payload.offset, payload.length);
+    case "fs.readMany":
+      return files.readMany(payload.paths);
+    case "fs.write":
+      return files.write(payload.path, payload.content, payload.mode);
+    case "fs.edit":
+      return files.edit(payload.path, payload.oldText, payload.newText, payload.expectedReplacements);
+    case "fs.mkdir":
+      return files.mkdir(payload.path);
+    case "fs.move":
+      return files.move(payload.source, payload.destination);
+    case "fs.delete":
+      return files.remove(payload.path, payload.recursive);
+    case "fs.search.start":
+      return files.startSearch(payload.path, payload.pattern, payload.searchType, payload.maxResults);
+    case "fs.search.results":
+      return files.getSearchResults(payload.sessionId, payload.offset, payload.length);
+
+    case "process.list":
+      return processes.list(payload.filter);
+    case "process.kill":
+      return processes.kill(payload.pid);
+
+    case "terminal.exec":
+      if (!terminalEnabled) return { ok: false, error: "terminal_disabled" };
+      return terminals.exec(payload.command, payload.cwd, payload.timeoutMs);
+    case "terminal.start":
+      if (!terminalEnabled) return { ok: false, error: "terminal_disabled" };
+      return terminals.start(payload.command, payload.cwd);
+    case "terminal.shell.start":
+      if (!terminalEnabled) return { ok: false, error: "terminal_disabled" };
+      return terminals.startShell(payload.cwd);
+    case "terminal.read":
+      if (!terminalEnabled) return { ok: false, error: "terminal_disabled" };
+      return terminals.read(payload.sessionId, payload.afterSeq, payload.maxChars);
+    case "terminal.write":
+      if (!terminalEnabled) return { ok: false, error: "terminal_disabled" };
+      return terminals.write(payload.sessionId, payload.input, payload.appendNewline !== false);
+    case "terminal.kill":
+      if (!terminalEnabled) return { ok: false, error: "terminal_disabled" };
+      return terminals.kill(payload.sessionId);
+    case "terminal.list":
+      if (!terminalEnabled) return { ok: false, error: "terminal_disabled" };
+      return terminals.list();
+
+    default:
+      return { ok: false, error: "unknown_action" };
+  }
+}
+
+function connect() {
+  console.log(`Connecting to ${wsUrl}`);
+  console.log(`Terminal access: ${terminalEnabled ? "enabled" : "disabled"}`);
+  const socket = new WebSocket(wsUrl, {
+    headers: { Authorization: `Bearer ${agentToken}` },
+  });
+
+  socket.on("open", () => console.log("Agent connected"));
+
+  socket.on("message", async (raw) => {
+    let message;
+    try {
+      message = JSON.parse(raw.toString());
+    } catch {
+      return;
+    }
+
+    if (!message || typeof message.requestId !== "string") return;
+
+    const startedAt = Date.now();
+    const action = message.payload && typeof message.payload === "object"
+      ? String(message.payload.action ?? "unknown")
+      : "unknown";
+    try {
+      const result = await handlePayload(message.payload);
+      recentCalls.push({
+        at: new Date().toISOString(),
+        action,
+        durationMs: Date.now() - startedAt,
+        ok: !(result && typeof result === "object" && result.ok === false),
+      });
+      if (recentCalls.length > 100) recentCalls.shift();
+      socket.send(JSON.stringify({ requestId: message.requestId, payload: result }));
+    } catch (error) {
+      recentCalls.push({
+        at: new Date().toISOString(),
+        action,
+        durationMs: Date.now() - startedAt,
+        ok: false,
+        error: error instanceof Error ? error.message : "agent_error",
+      });
+      if (recentCalls.length > 100) recentCalls.shift();
+      socket.send(JSON.stringify({
+        requestId: message.requestId,
+        payload: { ok: false, error: error instanceof Error ? error.message : "agent_error" },
+      }));
+    }
+  });
+
+  socket.on("close", (code, reason) => {
+    console.log(`Agent disconnected (${code}) ${reason.toString()}`);
+    setTimeout(connect, reconnectMs);
+  });
+
+  socket.on("error", (error) => {
+    console.error("WebSocket error:", error.message);
+  });
+}
+
+connect();