ragent-cli 1.2.1 → 1.3.1

package/dist/index.js

@@ -31,7 +31,7 @@ var require_package = __commonJS({
   "package.json"(exports2, module2) {
     module2.exports = {
       name: "ragent-cli",
-      version: "1.2.1",
+      version: "1.3.1",
       description: "CLI agent for rAgent Live \u2014 browser-first terminal control plane for AI coding agents",
       main: "dist/index.js",
       bin: {
@@ -41,7 +41,11 @@ var require_package = __commonJS({
         build: "tsup",
         dev: "tsup --watch",
         test: "vitest run",
-        typecheck: "tsc --noEmit"
+        typecheck: "tsc --noEmit",
+        lint: "eslint src/",
+        changeset: "changeset",
+        "version-packages": "changeset version",
+        release: "npm run build && npm run test && changeset publish"
       },
       keywords: [
         "terminal",
@@ -81,12 +85,17 @@ var require_package = __commonJS({
         ws: "^8.19.0"
       },
       devDependencies: {
+        "@changesets/changelog-github": "^0.5.2",
+        "@changesets/cli": "^2.29.8",
+        "@eslint/js": "^10.0.1",
         "@types/figlet": "^1.7.0",
-        "@types/node": "^20.17.0",
+        "@types/node": "^25.3.0",
         "@types/ws": "^8.5.13",
+        eslint: "^10.0.2",
         tsup: "^8.4.0",
         typescript: "^5.7.0",
-        vitest: "^3.0.0"
+        "typescript-eslint": "^8.56.1",
+        vitest: "^4.0.18"
       }
     };
   }
@@ -509,11 +518,11 @@ function detectAgentType(command) {
   const parts = cmd.split(/\s+/);
   const binary = parts[0]?.split("/").pop() ?? "";
   const scriptArg = binary === "node" && parts[1] ? parts[1].split("/").pop() ?? "" : "";
-  if (binary === "claude" || scriptArg === "cli.js" && cmd.includes("claude-code")) {
+  if (binary === "claude" || binary === "claude-code" || scriptArg === "cli.js" && cmd.includes("claude-code")) {
     if (cmd.includes("--chrome-native-host")) return void 0;
     return "Claude Code";
   }
-  if (binary === "codex" || cmd.includes("codex-cli")) return "Codex CLI";
+  if (binary === "codex" || scriptArg === "codex" || cmd.includes("codex-cli")) return "Codex CLI";
   if (binary === "aider") return "aider";
   if (binary === "cursor") return "Cursor";
   if (binary === "windsurf") return "Windsurf";
@@ -1103,22 +1112,66 @@ function requestStopSelfService() {
 
 // src/websocket.ts
 var import_ws = __toESM(require("ws"));
+var BACKPRESSURE_HIGH_WATER = 256 * 1024;
+function sanitizeForJson(str) {
+  return str.replace(/[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?<![\uD800-\uDBFF])[\uDC00-\uDFFF]/g, "\uFFFD");
+}
 function sendToGroup(ws, group, data) {
   if (!group || ws.readyState !== import_ws.default.OPEN) return;
+  if (ws.bufferedAmount > BACKPRESSURE_HIGH_WATER) {
+    return;
+  }
+  const sanitized = sanitizePayload(data);
   ws.send(
     JSON.stringify({
       type: "sendToGroup",
       group,
       dataType: "json",
-      data,
+      data: sanitized,
       noEcho: true
     })
   );
 }
+function sanitizePayload(obj) {
+  const result = {};
+  for (const [key, value] of Object.entries(obj)) {
+    if (typeof value === "string") {
+      result[key] = sanitizeForJson(value);
+    } else if (value !== null && typeof value === "object" && !Array.isArray(value)) {
+      result[key] = sanitizePayload(value);
+    } else {
+      result[key] = value;
+    }
+  }
+  return result;
+}
 
 // src/session-streamer.ts
+var import_node_child_process3 = require("child_process");
+var import_node_fs = require("fs");
+var import_node_path = require("path");
+var import_node_os = require("os");
 var pty2 = __toESM(require("node-pty"));
 var STOP_DEBOUNCE_MS = 2e3;
+function parsePaneTarget(sessionId) {
+  if (!sessionId.startsWith("tmux:")) return null;
+  const rest = sessionId.slice("tmux:".length);
+  if (!rest) return null;
+  return rest;
+}
+function parseScreenSession(sessionId) {
+  if (!sessionId.startsWith("screen:")) return null;
+  const rest = sessionId.slice("screen:".length);
+  if (!rest) return null;
+  const name = rest.split(":")[0];
+  return name || null;
+}
+function parseZellijSession(sessionId) {
+  if (!sessionId.startsWith("zellij:")) return null;
+  const rest = sessionId.slice("zellij:".length);
+  if (!rest) return null;
+  return rest.split(":")[0] || null;
+}
 var SessionStreamer = class {
   active = /* @__PURE__ */ new Map();
   pendingStops = /* @__PURE__ */ new Map();
@@ -1129,7 +1182,7 @@ var SessionStreamer = class {
     this.onStreamStopped = onStreamStopped;
   }
   /**
-   * Start streaming a tmux session. Returns true if streaming started.
+   * Start streaming a session. Dispatches based on session type prefix.
    */
   startStream(sessionId) {
     const pendingStop = this.pendingStops.get(sessionId);
@@ -1144,39 +1197,29 @@ var SessionStreamer = class {
     if (this.active.has(sessionId)) {
       return true;
     }
-    const parts = sessionId.split(":");
-    if (parts[0] !== "tmux" || parts.length < 2) {
-      return false;
+    if (sessionId.startsWith("tmux:")) {
+      return this.startTmuxStream(sessionId);
     }
-    const tmuxSession = parts[1];
+    if (sessionId.startsWith("screen:")) {
+      return this.startScreenStream(sessionId);
+    }
+    if (sessionId.startsWith("zellij:")) {
+      return this.startZellijStream(sessionId);
+    }
+    return false;
+  }
+  /**
+   * Write input to a PTY-attached stream (screen/zellij).
+   * tmux input is handled separately via sendInputToTmux.
+   */
+  writeInput(sessionId, data) {
+    const stream = this.active.get(sessionId);
+    if (!stream || stream.stopped || stream.streamType !== "pty-attach" || !stream.ptyProc) return;
     try {
-      const cleanEnv = { ...process.env };
-      delete cleanEnv.TMUX;
-      delete cleanEnv.TMUX_PANE;
-      const proc = pty2.spawn("tmux", ["attach-session", "-t", tmuxSession, "-r"], {
-        name: "xterm-256color",
-        cols: 120,
-        rows: 40,
-        cwd: process.cwd(),
-        env: cleanEnv
-      });
-      const stream = { pty: proc, sessionId, tmuxSession };
-      this.active.set(sessionId, stream);
-      proc.onData((data) => {
-        this.sendFn(sessionId, data);
-      });
-      proc.onExit(({ exitCode, signal }) => {
-        this.active.delete(sessionId);
-        this.pendingStops.delete(sessionId);
-        console.log(`[rAgent] Session stream ended: ${sessionId} (exit=${exitCode}, signal=${signal})`);
-        this.onStreamStopped?.(sessionId);
-      });
-      console.log(`[rAgent] Started streaming: ${sessionId} (tmux session: ${tmuxSession})`);
-      return true;
+      stream.ptyProc.write(data);
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
-      console.warn(`[rAgent] Failed to start stream for ${sessionId}: ${message}`);
-      return false;
+      console.warn(`[rAgent] Failed to write input to ${sessionId}: ${message}`);
     }
   }
   /**
@@ -1190,10 +1233,7 @@ var SessionStreamer = class {
       this.pendingStops.delete(sessionId);
       const s = this.active.get(sessionId);
       if (!s) return;
-      try {
-        s.pty.kill();
-      } catch {
-      }
+      this.cleanupStream(s);
       this.active.delete(sessionId);
       console.log(`[rAgent] Stopped streaming: ${sessionId}`);
     }, STOP_DEBOUNCE_MS);
@@ -1214,10 +1254,7 @@ var SessionStreamer = class {
     }
     this.pendingStops.clear();
     for (const [id, stream] of this.active) {
-      try {
-        stream.pty.kill();
-      } catch {
-      }
+      this.cleanupStream(stream);
       console.log(`[rAgent] Stopped streaming: ${id}`);
     }
     this.active.clear();
@@ -1228,6 +1265,247 @@ var SessionStreamer = class {
   get activeCount() {
     return this.active.size;
   }
+  // ---------------------------------------------------------------------------
+  // tmux streaming (pipe-pane with cursor sync)
+  // ---------------------------------------------------------------------------
+  startTmuxStream(sessionId) {
+    const paneTarget = parsePaneTarget(sessionId);
+    if (!paneTarget) return false;
+    try {
+      const cleanEnv = { ...process.env };
+      delete cleanEnv.TMUX;
+      delete cleanEnv.TMUX_PANE;
+      const streamsBase = (0, import_node_path.join)((0, import_node_os.homedir)(), ".config", "ragent", "streams");
+      try {
+        (0, import_node_fs.mkdirSync)(streamsBase, { recursive: true });
+      } catch {
+      }
+      let tmpDir;
+      try {
+        tmpDir = (0, import_node_fs.mkdtempSync)((0, import_node_path.join)(streamsBase, "s-"));
+      } catch {
+        tmpDir = (0, import_node_fs.mkdtempSync)((0, import_node_path.join)((0, import_node_os.tmpdir)(), "ragent-stream-"));
+      }
+      const fifoPath = (0, import_node_path.join)(tmpDir, "pane.fifo");
+      (0, import_node_child_process3.execFileSync)("mkfifo", ["-m", "600", fifoPath]);
+      const stream = {
+        sessionId,
+        streamType: "tmux-pipe",
+        paneTarget,
+        fifoPath,
+        tmpDir,
+        catProc: null,
+        stopped: false,
+        initializing: true,
+        initBuffer: [],
+        ptyProc: null
+      };
+      this.active.set(sessionId, stream);
+      try {
+        (0, import_node_child_process3.execFileSync)(
+          "tmux",
+          ["pipe-pane", "-O", "-t", paneTarget, `cat > ${fifoPath}`],
+          { env: cleanEnv, timeout: 5e3 }
+        );
+      } catch (error) {
+        this.cleanupStream(stream);
+        const message = error instanceof Error ? error.message : String(error);
+        console.warn(`[rAgent] Failed pipe-pane for ${sessionId}: ${message}`);
+        return false;
+      }
+      const catProc = (0, import_node_child_process3.spawn)("cat", [fifoPath], { env: cleanEnv, stdio: ["ignore", "pipe", "ignore"] });
+      stream.catProc = catProc;
+      catProc.stdout.on("data", (chunk) => {
+        if (stream.stopped) return;
+        const data = chunk.toString("utf-8");
+        if (stream.initializing) {
+          stream.initBuffer.push(data);
+        } else {
+          this.sendFn(sessionId, data);
+        }
+      });
+      catProc.on("exit", () => {
+        if (!stream.stopped) {
+          this.cleanupStream(stream);
+          this.active.delete(sessionId);
+          this.pendingStops.delete(sessionId);
+          console.log(`[rAgent] Session stream ended: ${sessionId}`);
+          this.onStreamStopped?.(sessionId);
+        }
+      });
+      this.sendFn(sessionId, "\x1B[2J\x1B[H");
+      try {
+        const initial = (0, import_node_child_process3.execFileSync)(
+          "tmux",
+          ["capture-pane", "-t", paneTarget, "-p", "-e"],
+          { env: cleanEnv, timeout: 5e3, encoding: "utf-8" }
+        );
+        if (initial) {
+          this.sendFn(sessionId, initial);
+        }
+      } catch {
+      }
+      try {
+        const cursorInfo = (0, import_node_child_process3.execFileSync)(
+          "tmux",
+          ["display-message", "-t", paneTarget, "-p", "#{cursor_x} #{cursor_y}"],
+          { env: cleanEnv, timeout: 5e3, encoding: "utf-8" }
+        ).trim();
+        const parts = cursorInfo.split(" ");
+        if (parts.length === 2) {
+          const x = parseInt(parts[0], 10);
+          const y = parseInt(parts[1], 10);
+          if (!isNaN(x) && !isNaN(y)) {
+            this.sendFn(sessionId, `\x1B[${y + 1};${x + 1}H`);
+          }
+        }
+      } catch {
+      }
+      stream.initializing = false;
+      if (stream.initBuffer.length > 0) {
+        for (const buffered of stream.initBuffer) {
+          this.sendFn(sessionId, buffered);
+        }
+        stream.initBuffer = [];
+      }
+      console.log(`[rAgent] Started streaming: ${sessionId} (pane: ${paneTarget})`);
+      return true;
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      console.warn(`[rAgent] Failed to start stream for ${sessionId}: ${message}`);
+      return false;
+    }
+  }
+  // ---------------------------------------------------------------------------
+  // screen streaming (screen -x in node-pty)
+  // ---------------------------------------------------------------------------
+  startScreenStream(sessionId) {
+    const sessionName = parseScreenSession(sessionId);
+    if (!sessionName) return false;
+    try {
+      const proc = pty2.spawn("screen", ["-x", sessionName], {
+        name: "xterm-256color",
+        cols: 80,
+        rows: 30,
+        cwd: process.cwd(),
+        env: process.env
+      });
+      const stream = {
+        sessionId,
+        streamType: "pty-attach",
+        stopped: false,
+        paneTarget: "",
+        fifoPath: "",
+        tmpDir: "",
+        catProc: null,
+        initializing: false,
+        initBuffer: [],
+        ptyProc: proc
+      };
+      this.active.set(sessionId, stream);
+      proc.onData((data) => {
+        if (!stream.stopped) {
+          this.sendFn(sessionId, data);
+        }
+      });
+      proc.onExit(() => {
+        if (!stream.stopped) {
+          stream.stopped = true;
+          this.active.delete(sessionId);
+          this.pendingStops.delete(sessionId);
+          console.log(`[rAgent] Session stream ended: ${sessionId}`);
+          this.onStreamStopped?.(sessionId);
+        }
+      });
+      console.log(`[rAgent] Started streaming: ${sessionId} (screen: ${sessionName})`);
+      return true;
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      console.warn(`[rAgent] Failed to start screen stream for ${sessionId}: ${message}`);
+      return false;
+    }
+  }
+  // ---------------------------------------------------------------------------
+  // zellij streaming (zellij attach in node-pty)
+  // ---------------------------------------------------------------------------
+  startZellijStream(sessionId) {
+    const sessionName = parseZellijSession(sessionId);
+    if (!sessionName) return false;
+    try {
+      const proc = pty2.spawn("zellij", ["attach", sessionName], {
+        name: "xterm-256color",
+        cols: 80,
+        rows: 30,
+        cwd: process.cwd(),
+        env: process.env
+      });
+      const stream = {
+        sessionId,
+        streamType: "pty-attach",
+        stopped: false,
+        paneTarget: "",
+        fifoPath: "",
+        tmpDir: "",
+        catProc: null,
+        initializing: false,
+        initBuffer: [],
+        ptyProc: proc
+      };
+      this.active.set(sessionId, stream);
+      proc.onData((data) => {
+        if (!stream.stopped) {
+          this.sendFn(sessionId, data);
+        }
+      });
+      proc.onExit(() => {
+        if (!stream.stopped) {
+          stream.stopped = true;
+          this.active.delete(sessionId);
+          this.pendingStops.delete(sessionId);
+          console.log(`[rAgent] Session stream ended: ${sessionId}`);
+          this.onStreamStopped?.(sessionId);
+        }
+      });
+      console.log(`[rAgent] Started streaming: ${sessionId} (zellij: ${sessionName})`);
+      return true;
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      console.warn(`[rAgent] Failed to start zellij stream for ${sessionId}: ${message}`);
+      return false;
+    }
+  }
+  // ---------------------------------------------------------------------------
+  // Cleanup
+  // ---------------------------------------------------------------------------
+  cleanupStream(stream) {
+    stream.stopped = true;
+    if (stream.streamType === "tmux-pipe") {
+      try {
+        (0, import_node_child_process3.execFileSync)("tmux", ["pipe-pane", "-t", stream.paneTarget], { timeout: 5e3 });
+      } catch {
+      }
+      if (stream.catProc && !stream.catProc.killed) {
+        try {
+          stream.catProc.kill("SIGTERM");
+        } catch {
+        }
+      }
+      try {
+        if (stream.tmpDir && (0, import_node_fs.existsSync)(stream.tmpDir)) {
+          (0, import_node_fs.rmSync)(stream.tmpDir, { recursive: true, force: true });
+        }
+      } catch {
+      }
+    } else if (stream.streamType === "pty-attach") {
+      if (stream.ptyProc) {
+        try {
+          stream.ptyProc.kill();
+        } catch {
+        }
+        stream.ptyProc = null;
+      }
+    }
+  }
 };
 
 // src/provisioner.ts
@@ -1511,6 +1789,8 @@ async function runAgent(rawOptions) {
   let activeGroups = { privateGroup: "", registryGroup: "" };
   let wsHeartbeatTimer = null;
   let httpHeartbeatTimer = null;
+  let wsPingTimer = null;
+  let wsPongTimeout = null;
   let suppressNextShellRespawn = false;
   let lastSentFingerprint = "";
   let lastHttpHeartbeatAt = 0;
@@ -1566,6 +1846,14 @@ async function runAgent(rawOptions) {
   spawnOrRespawnShell();
   const cleanupSocket = (opts = {}) => {
     if (opts.stopStreams) sessionStreamer.stopAll();
+    if (wsPingTimer) {
+      clearInterval(wsPingTimer);
+      wsPingTimer = null;
+    }
+    if (wsPongTimeout) {
+      clearTimeout(wsPongTimeout);
+      wsPongTimeout = null;
+    }
     if (wsHeartbeatTimer) {
       clearInterval(wsHeartbeatTimer);
       wsHeartbeatTimer = null;
@@ -1584,17 +1872,28 @@ async function runAgent(rawOptions) {
     }
     activeGroups = { privateGroup: "", registryGroup: "" };
   };
-  const collectVitals = () => {
+  let prevCpuSnapshot = null;
+  function takeCpuSnapshot() {
     const cpus2 = os5.cpus();
-    let totalIdle = 0;
-    let totalTick = 0;
+    let idle = 0;
+    let total = 0;
     for (const cpu of cpus2) {
       for (const type of Object.keys(cpu.times)) {
-        totalTick += cpu.times[type];
+        total += cpu.times[type];
       }
-      totalIdle += cpu.times.idle;
+      idle += cpu.times.idle;
     }
-    const cpuUsage = totalTick > 0 ? Math.round((totalTick - totalIdle) / totalTick * 100) : 0;
+    return { idle, total };
+  }
+  const collectVitals = () => {
+    const currentSnapshot = takeCpuSnapshot();
+    let cpuUsage = 0;
+    if (prevCpuSnapshot) {
+      const idleDelta = currentSnapshot.idle - prevCpuSnapshot.idle;
+      const totalDelta = currentSnapshot.total - prevCpuSnapshot.total;
+      cpuUsage = totalDelta > 0 ? Math.round((totalDelta - idleDelta) / totalDelta * 100) : 0;
+    }
+    prevCpuSnapshot = currentSnapshot;
     const totalMem = os5.totalmem();
     const freeMem = os5.freemem();
     const memUsedPct = totalMem > 0 ? Math.round((totalMem - freeMem) / totalMem * 100) : 0;
@@ -1725,8 +2024,8 @@ async function runAgent(rawOptions) {
         }
         tmuxArgs.push(fullCmd);
         try {
-          const { execFileSync: execFileSync2 } = await import("child_process");
-          execFileSync2("tmux", tmuxArgs, { stdio: "ignore" });
+          const { execFileSync: execFileSync3 } = await import("child_process");
+          execFileSync3("tmux", tmuxArgs, { stdio: "ignore" });
           console.log(`[rAgent] Started agent session "${sessionName}": ${cmd}`);
         } catch (error) {
           const message = error instanceof Error ? error.message : String(error);
@@ -1743,12 +2042,12 @@ async function runAgent(rawOptions) {
             sendToGroup(ws2, activeGroups.privateGroup, {
               type: "stream-error",
               sessionId,
-              error: "Live output is not available for standalone processes. Start agents inside tmux for live monitoring."
+              error: "This agent is running outside a terminal multiplexer. Stop and relaunch via Start Agent to enable live streaming."
             });
           }
           return;
         }
-        if (sessionId.startsWith("tmux:")) {
+        if (sessionId.startsWith("tmux:") || sessionId.startsWith("screen:") || sessionId.startsWith("zellij:")) {
           const started = sessionStreamer.startStream(sessionId);
           const ws2 = activeSocket;
           if (ws2 && ws2.readyState === import_ws2.default.OPEN && activeGroups.privateGroup) {
@@ -1761,7 +2060,7 @@ async function runAgent(rawOptions) {
               sendToGroup(ws2, activeGroups.privateGroup, {
                 type: "stream-error",
                 sessionId,
-                error: "Failed to attach to tmux session. It may no longer exist."
+                error: "Failed to attach to session. It may no longer exist."
               });
             }
           }
@@ -1772,7 +2071,7 @@ async function runAgent(rawOptions) {
           sendToGroup(ws, activeGroups.privateGroup, {
             type: "stream-error",
             sessionId,
-            error: `Streaming not yet supported for session type: ${sessionId.split(":")[0]}`
+            error: "Live streaming is not yet supported for this session type."
           });
         }
         return;
@@ -1859,6 +2158,23 @@ async function runAgent(rawOptions) {
                 return;
               await syncInventory();
             }, HTTP_HEARTBEAT_MS);
+            wsPingTimer = setInterval(() => {
+              if (!activeSocket || activeSocket.readyState !== import_ws2.default.OPEN) return;
+              activeSocket.ping();
+              wsPongTimeout = setTimeout(() => {
+                console.warn("[rAgent] No pong received within 10s \u2014 closing stale connection.");
+                try {
+                  activeSocket?.terminate();
+                } catch {
+                }
+              }, 1e4);
+            }, 2e4);
+          });
+          ws.on("pong", () => {
+            if (wsPongTimeout) {
+              clearTimeout(wsPongTimeout);
+              wsPongTimeout = null;
+            }
           });
           ws.on("message", async (data) => {
             let msg;
@@ -1875,6 +2191,8 @@ async function runAgent(rawOptions) {
                   if (ptyProcess) ptyProcess.write(payload.data);
                 } else if (sid.startsWith("tmux:")) {
                   await sendInputToTmux(sid, payload.data);
+                } else if (sid.startsWith("screen:") || sid.startsWith("zellij:")) {
+                  sessionStreamer.writeInput(sid, payload.data);
                 }
               } else if (payload.type === "resize" && Number.isInteger(payload.cols) && Number.isInteger(payload.rows)) {
                 const sid = typeof payload.sessionId === "string" ? payload.sessionId.trim() : "";
@@ -1960,10 +2278,11 @@ async function runAgent(rawOptions) {
         await wait(300);
         continue;
       }
+      const jitteredDelay = reconnectDelay * (0.5 + Math.random());
       console.log(
-        `[rAgent] Disconnected. Reconnecting in ${Math.round(reconnectDelay / 1e3)}s...`
+        `[rAgent] Disconnected. Reconnecting in ${Math.round(jitteredDelay / 1e3)}s...`
       );
-      await wait(reconnectDelay);
+      await wait(jitteredDelay);
       reconnectDelay = Math.min(reconnectDelay * 1.5, MAX_RECONNECT_DELAY_MS);
     }
   } finally {
@@ -2373,6 +2692,10 @@ function registerUninstallCommand(parent) {
 }
 
 // src/index.ts
+process.on("unhandledRejection", (reason) => {
+  const message = reason instanceof Error ? reason.stack || reason.message : String(reason);
+  console.error(`[rAgent] Unhandled promise rejection: ${message}`);
+});
 import_commander.program.name("ragent").description("Connect machines to rAgent Live").version(CURRENT_VERSION);
 registerConnectCommand(import_commander.program);
 registerRunCommand(import_commander.program);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ragent-cli",
-  "version": "1.2.1",
+  "version": "1.3.1",
   "description": "CLI agent for rAgent Live — browser-first terminal control plane for AI coding agents",
   "main": "dist/index.js",
   "bin": {
@@ -10,7 +10,11 @@
     "build": "tsup",
     "dev": "tsup --watch",
     "test": "vitest run",
-    "typecheck": "tsc --noEmit"
+    "typecheck": "tsc --noEmit",
+    "lint": "eslint src/",
+    "changeset": "changeset",
+    "version-packages": "changeset version",
+    "release": "npm run build && npm run test && changeset publish"
   },
   "keywords": [
     "terminal",
@@ -50,11 +54,16 @@
     "ws": "^8.19.0"
   },
   "devDependencies": {
+    "@changesets/changelog-github": "^0.5.2",
+    "@changesets/cli": "^2.29.8",
+    "@eslint/js": "^10.0.1",
     "@types/figlet": "^1.7.0",
-    "@types/node": "^20.17.0",
+    "@types/node": "^25.3.0",
     "@types/ws": "^8.5.13",
+    "eslint": "^10.0.2",
     "tsup": "^8.4.0",
     "typescript": "^5.7.0",
-    "vitest": "^3.0.0"
+    "typescript-eslint": "^8.56.1",
+    "vitest": "^4.0.18"
   }
 }