maxsimcli 2.1.1 → 2.2.0

package/dist/assets/dashboard/server.js

@@ -69,6 +69,8 @@ node_tty = __toESM(node_tty);
 let fs_promises = require("fs/promises");
 let node_stream = require("node:stream");
 let os = require("os");
+let node_pty = require("node-pty");
+node_pty = __toESM(node_pty);
 
 //#region ../../node_modules/.pnpm/depd@2.0.0/node_modules/depd/index.js
 var require_depd = /* @__PURE__ */ __commonJSMin(((exports, module) => {
@@ -41393,6 +41395,162 @@ function watch(paths, options = {}) {
 	return watcher;
 }
 
+//#endregion
+//#region src/terminal/session-store.ts
+const MAX_SCROLLBACK = 5e4;
+var SessionStore = class {
+	scrollback = [];
+	append(data) {
+		this.scrollback.push(data);
+		if (this.scrollback.length > MAX_SCROLLBACK) this.scrollback = this.scrollback.slice(-MAX_SCROLLBACK);
+	}
+	getAll() {
+		return this.scrollback.join("");
+	}
+	clear() {
+		this.scrollback = [];
+	}
+};
+
+//#endregion
+//#region src/terminal/pty-manager.ts
+const DISCONNECT_TIMEOUT_MS = 6e4;
+const STATUS_INTERVAL_MS = 1e3;
+const ACTIVE_THRESHOLD_MS = 2e3;
+var PtyManager = class PtyManager {
+	static instance = null;
+	session = null;
+	connectedClients = /* @__PURE__ */ new Set();
+	lastOutputTime = 0;
+	statusInterval = null;
+	static getInstance() {
+		if (!PtyManager.instance) PtyManager.instance = new PtyManager();
+		return PtyManager.instance;
+	}
+	spawn(opts) {
+		if (this.session) this.kill();
+		const shell = process.platform === "win32" ? "claude.cmd" : "claude";
+		const args = [];
+		if (opts.skipPermissions) args.push("--dangerously-skip-permissions");
+		const proc = node_pty.spawn(shell, args, {
+			name: "xterm-256color",
+			cols: opts.cols ?? 120,
+			rows: opts.rows ?? 30,
+			cwd: opts.cwd,
+			env: process.env
+		});
+		const store = new SessionStore();
+		this.session = {
+			process: proc,
+			pid: proc.pid,
+			startTime: Date.now(),
+			cwd: opts.cwd,
+			skipPermissions: opts.skipPermissions,
+			disconnectTimer: null,
+			store
+		};
+		this.lastOutputTime = Date.now();
+		proc.onData((data) => {
+			this.lastOutputTime = Date.now();
+			store.append(data);
+			this.broadcastToClients({
+				type: "output",
+				data
+			});
+		});
+		proc.onExit(({ exitCode }) => {
+			this.broadcastToClients({
+				type: "exit",
+				code: exitCode
+			});
+			this.stopStatusBroadcast();
+			this.session = null;
+		});
+		this.broadcastToClients({
+			type: "started",
+			pid: proc.pid
+		});
+		this.startStatusBroadcast();
+	}
+	write(data) {
+		if (this.session) this.session.process.write(data);
+	}
+	resize(cols, rows) {
+		if (this.session) this.session.process.resize(cols, rows);
+	}
+	kill() {
+		if (this.session) {
+			this.stopStatusBroadcast();
+			try {
+				this.session.process.kill();
+			} catch {}
+			if (this.session.disconnectTimer) clearTimeout(this.session.disconnectTimer);
+			this.session = null;
+		}
+	}
+	getStatus() {
+		if (!this.session) return null;
+		return {
+			pid: this.session.pid,
+			uptime: Math.floor((Date.now() - this.session.startTime) / 1e3),
+			cwd: this.session.cwd,
+			memoryMB: Math.round(process.memoryUsage().rss / 1024 / 1024 * 10) / 10,
+			isActive: Date.now() - this.lastOutputTime < ACTIVE_THRESHOLD_MS,
+			skipPermissions: this.session.skipPermissions,
+			alive: true
+		};
+	}
+	addClient(ws) {
+		this.connectedClients.add(ws);
+		if (this.session?.disconnectTimer) {
+			clearTimeout(this.session.disconnectTimer);
+			this.session.disconnectTimer = null;
+		}
+		if (this.session) {
+			const scrollback = this.session.store.getAll();
+			if (scrollback) ws.send(JSON.stringify({
+				type: "scrollback",
+				data: scrollback
+			}));
+			const status = this.getStatus();
+			if (status) ws.send(JSON.stringify({
+				type: "status",
+				...status
+			}));
+		}
+	}
+	removeClient(ws) {
+		this.connectedClients.delete(ws);
+		if (this.connectedClients.size === 0 && this.session) this.session.disconnectTimer = setTimeout(() => {
+			console.error("[pty] No clients connected for 60s, killing process");
+			this.kill();
+		}, DISCONNECT_TIMEOUT_MS);
+	}
+	isAlive() {
+		return this.session !== null;
+	}
+	broadcastToClients(message) {
+		const data = JSON.stringify(message);
+		for (const client of this.connectedClients) if (client.readyState === import_websocket.default.OPEN) client.send(data);
+	}
+	startStatusBroadcast() {
+		this.stopStatusBroadcast();
+		this.statusInterval = setInterval(() => {
+			const status = this.getStatus();
+			if (status) this.broadcastToClients({
+				type: "status",
+				...status
+			});
+		}, STATUS_INTERVAL_MS);
+	}
+	stopStatusBroadcast() {
+		if (this.statusInterval) {
+			clearInterval(this.statusInterval);
+			this.statusInterval = null;
+		}
+	}
+};
+
 //#endregion
 //#region src/server.ts
 const projectCwd = process.env.MAXSIM_PROJECT_CWD || process.cwd();
@@ -41894,10 +42052,48 @@ else app.get("/", (_req, res) => {
 });
 async function main() {
 	const wss = createWSS();
+	const terminalWss = new import_websocket_server.default({ noServer: true });
+	const ptyManager = PtyManager.getInstance();
+	terminalWss.on("connection", (ws) => {
+		ptyManager.addClient(ws);
+		ws.on("message", (raw) => {
+			try {
+				const msg = JSON.parse(typeof raw === "string" ? raw : raw.toString());
+				switch (msg.type) {
+					case "input":
+						ptyManager.write(msg.data);
+						break;
+					case "resize":
+						ptyManager.resize(msg.cols, msg.rows);
+						break;
+					case "spawn":
+						ptyManager.spawn({
+							skipPermissions: !!msg.skipPermissions,
+							cwd: projectCwd,
+							cols: msg.cols,
+							rows: msg.rows
+						});
+						break;
+					case "kill":
+						ptyManager.kill();
+						break;
+				}
+			} catch {}
+		});
+		ws.on("close", () => {
+			ptyManager.removeClient(ws);
+		});
+		ws.on("error", (err) => {
+			console.error("[terminal-ws] Client error:", err.message);
+		});
+	});
 	const server = (0, node_http.createServer)(app);
 	server.on("upgrade", (req, socket, head) => {
 		const url = req.url || "/";
-		if (url === "/api/ws" || url.startsWith("/api/ws?")) wss.handleUpgrade(req, socket, head, (ws) => {
+		if (url === "/ws/terminal" || url.startsWith("/ws/terminal?")) terminalWss.handleUpgrade(req, socket, head, (ws) => {
+			terminalWss.emit("connection", ws, req);
+		});
+		else if (url === "/api/ws" || url.startsWith("/api/ws?")) wss.handleUpgrade(req, socket, head, (ws) => {
 			wss.emit("connection", ws, req);
 		});
 		else socket.destroy();
@@ -41916,7 +42112,9 @@ async function main() {
 	});
 	function shutdown() {
 		console.error("\n[server] Shutting down...");
+		ptyManager.kill();
 		if (watcher) watcher.close().catch(() => {});
+		terminalWss.close(() => {});
 		wss.close(() => {
 			server.close(() => {
 				process.exit(0);
@@ -41929,6 +42127,9 @@ async function main() {
 	}
 	process.on("SIGINT", shutdown);
 	process.on("SIGTERM", shutdown);
+	process.on("exit", () => {
+		ptyManager.kill();
+	});
 }
 main().catch((err) => {
 	console.error("[server] Fatal error:", err);

package/dist/install.cjs

@@ -7548,6 +7548,20 @@ async function promptLocation(runtimes) {
 	}) === "global";
 }
 /**
+* Prompt whether to enable Agent Teams (Claude only, experimental feature)
+*/
+async function promptAgentTeams() {
+	console.log();
+	console.log(chalk.cyan("  Agent Teams") + chalk.dim(" (experimental)"));
+	console.log(chalk.dim("  Coordinate multiple Claude Code instances working in parallel."));
+	console.log(chalk.dim("  Enables CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS in settings.json."));
+	console.log();
+	return dist_default$1({
+		message: "Enable Agent Teams?",
+		default: false
+	});
+}
+/**
 * Install MAXSIM for all selected runtimes
 */
 async function installAllRuntimes(runtimes, isGlobal, isInteractive) {
@@ -7560,8 +7574,15 @@ async function installAllRuntimes(runtimes, isGlobal, isInteractive) {
 	const primaryStatuslineResult = results.find((r) => statuslineRuntimes.includes(r.runtime));
 	let shouldInstallStatusline = false;
 	if (primaryStatuslineResult && primaryStatuslineResult.settings) shouldInstallStatusline = await handleStatusline(primaryStatuslineResult.settings, isInteractive);
+	let enableAgentTeams = false;
+	if (isInteractive && runtimes.includes("claude")) enableAgentTeams = await promptAgentTeams();
 	for (const result of results) {
 		const useStatusline = statuslineRuntimes.includes(result.runtime) && shouldInstallStatusline;
+		if (result.runtime === "claude" && enableAgentTeams && result.settings) {
+			const env = result.settings.env ?? {};
+			env["CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS"] = "1";
+			result.settings.env = env;
+		}
 		finishInstall(result.settingsPath, result.settings, result.statuslineCommand, useStatusline, result.runtime, isGlobal);
 	}
 }