webmux-agent 0.0.1

package/dist/cli.js

@@ -0,0 +1,567 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import os2 from "os";
+import { Command } from "commander";
+
+// src/credentials.ts
+import * as fs from "fs";
+import * as path from "path";
+import * as os from "os";
+function credentialsDir() {
+  return path.join(os.homedir(), ".webmux");
+}
+function credentialsPath() {
+  return path.join(credentialsDir(), "credentials.json");
+}
+function loadCredentials() {
+  const filePath = credentialsPath();
+  if (!fs.existsSync(filePath)) {
+    return null;
+  }
+  try {
+    const raw = fs.readFileSync(filePath, "utf-8");
+    const data = JSON.parse(raw);
+    if (!data.serverUrl || !data.agentId || !data.agentSecret || !data.name) {
+      return null;
+    }
+    return data;
+  } catch {
+    return null;
+  }
+}
+function saveCredentials(creds) {
+  const dir = credentialsDir();
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true, mode: 448 });
+  }
+  fs.writeFileSync(credentialsPath(), JSON.stringify(creds, null, 2) + "\n", {
+    mode: 384
+  });
+}
+
+// src/tmux.ts
+import { execFile } from "child_process";
+import { promisify } from "util";
+var execFileAsync = promisify(execFile);
+var FIELD_SEPARATOR = "";
+var SESSION_NAME_PATTERN = /^[a-zA-Z0-9][a-zA-Z0-9._-]{0,31}$/;
+var TMUX_EMPTY_STATE_MARKERS = [
+  "error connecting to",
+  "failed to connect to server",
+  "no server running",
+  "no sessions"
+];
+var TmuxClient = class {
+  socketName;
+  workspaceRoot;
+  constructor(options) {
+    this.socketName = options.socketName;
+    this.workspaceRoot = options.workspaceRoot;
+  }
+  async listSessions() {
+    const stdout = await this.run(
+      [
+        "list-sessions",
+        "-F",
+        [
+          "#{session_name}",
+          "#{session_windows}",
+          "#{session_attached}",
+          "#{session_created}",
+          "#{session_activity}",
+          "#{session_path}",
+          "#{pane_current_command}"
+        ].join(FIELD_SEPARATOR)
+      ],
+      { allowEmptyState: true }
+    );
+    const sessions = parseSessionList(stdout);
+    const enriched = await Promise.all(
+      sessions.map(async (session) => ({
+        ...session,
+        preview: await this.getPreview(session.name)
+      }))
+    );
+    return enriched.sort((left, right) => {
+      if (left.lastActivityAt !== right.lastActivityAt) {
+        return right.lastActivityAt - left.lastActivityAt;
+      }
+      return left.name.localeCompare(right.name);
+    });
+  }
+  async createSession(name) {
+    assertValidSessionName(name);
+    if (await this.hasSession(name)) {
+      return;
+    }
+    await this.run(["new-session", "-d", "-s", name, "-c", this.workspaceRoot]);
+  }
+  async killSession(name) {
+    assertValidSessionName(name);
+    await this.run(["kill-session", "-t", name]);
+  }
+  async readSession(name) {
+    const sessions = await this.listSessions();
+    return sessions.find((session) => session.name === name) ?? null;
+  }
+  async hasSession(name) {
+    try {
+      await this.run(["has-session", "-t", name]);
+      return true;
+    } catch (error) {
+      const message = String(
+        error.stderr ?? error.message
+      );
+      if (isTmuxEmptyStateMessage(message)) {
+        return false;
+      }
+      return false;
+    }
+  }
+  async getPreview(name) {
+    try {
+      const stdout = await this.run(
+        ["capture-pane", "-p", "-J", "-S", "-18", "-E", "-", "-t", `${name}:`],
+        { allowEmptyState: true }
+      );
+      return formatPreview(stdout);
+    } catch {
+      return ["Session available. Tap to attach."];
+    }
+  }
+  async run(args, options = {}) {
+    try {
+      const { stdout } = await execFileAsync(
+        "tmux",
+        ["-L", this.socketName, ...args],
+        {
+          cwd: this.workspaceRoot,
+          env: {
+            ...process.env,
+            TERM: "xterm-256color"
+          }
+        }
+      );
+      return stdout;
+    } catch (error) {
+      const message = String(
+        error.stderr ?? error.message
+      );
+      if (options.allowEmptyState && TMUX_EMPTY_STATE_MARKERS.some((marker) => message.includes(marker))) {
+        return "";
+      }
+      throw error;
+    }
+  }
+};
+function assertValidSessionName(name) {
+  if (!SESSION_NAME_PATTERN.test(name)) {
+    throw new Error(
+      "Invalid session name. Use up to 32 letters, numbers, dot, dash, or underscore."
+    );
+  }
+}
+function parseSessionList(stdout) {
+  return stdout.split("\n").map((line) => line.trim()).filter(Boolean).flatMap((line) => {
+    const parts = line.split(FIELD_SEPARATOR);
+    const [name, windows, attachedClients, createdAt, lastActivityAt, path2] = parts;
+    const currentCommand = parts[6] ?? "";
+    if (!name || !windows || !attachedClients || !createdAt || !lastActivityAt || !path2) {
+      return [];
+    }
+    return [
+      {
+        name,
+        windows: Number(windows),
+        attachedClients: Number(attachedClients),
+        createdAt: Number(createdAt),
+        lastActivityAt: Number(lastActivityAt),
+        path: path2,
+        currentCommand
+      }
+    ];
+  });
+}
+function formatPreview(stdout) {
+  const lines = stdout.replaceAll("\r", "").split("\n").map((line) => line.trimEnd()).filter((line) => line.length > 0).slice(-3);
+  if (lines.length > 0) {
+    return lines;
+  }
+  return ["Fresh session. Nothing has run yet."];
+}
+function isTmuxEmptyStateMessage(message) {
+  return TMUX_EMPTY_STATE_MARKERS.some((marker) => message.includes(marker));
+}
+
+// src/connection.ts
+import WebSocket from "ws";
+
+// src/terminal.ts
+import { spawn } from "node-pty";
+
+// ../shared/src/contracts.ts
+var DEFAULT_TERMINAL_SIZE = {
+  cols: 120,
+  rows: 36
+};
+
+// src/terminal.ts
+async function createTerminalBridge(options) {
+  const {
+    tmux,
+    sessionName,
+    cols = DEFAULT_TERMINAL_SIZE.cols,
+    rows = DEFAULT_TERMINAL_SIZE.rows,
+    onData,
+    onExit
+  } = options;
+  assertValidSessionName(sessionName);
+  await tmux.createSession(sessionName);
+  const ptyProcess = spawn(
+    "tmux",
+    ["-L", tmux.socketName, "attach-session", "-t", sessionName],
+    {
+      cols,
+      rows,
+      cwd: tmux.workspaceRoot,
+      env: {
+        ...process.env,
+        TERM: "xterm-256color"
+      },
+      name: "xterm-256color"
+    }
+  );
+  ptyProcess.onData(onData);
+  ptyProcess.onExit(({ exitCode }) => {
+    onExit(exitCode);
+  });
+  return {
+    write(data) {
+      ptyProcess.write(data);
+    },
+    resize(nextCols, nextRows) {
+      ptyProcess.resize(nextCols, nextRows);
+    },
+    dispose() {
+      ptyProcess.kill();
+    }
+  };
+}
+
+// src/connection.ts
+var HEARTBEAT_INTERVAL_MS = 3e4;
+var INITIAL_RECONNECT_DELAY_MS = 1e3;
+var MAX_RECONNECT_DELAY_MS = 3e4;
+var AgentConnection = class {
+  serverUrl;
+  agentId;
+  agentSecret;
+  tmux;
+  ws = null;
+  heartbeatTimer = null;
+  reconnectTimer = null;
+  reconnectDelay = INITIAL_RECONNECT_DELAY_MS;
+  bridges = /* @__PURE__ */ new Map();
+  stopped = false;
+  constructor(serverUrl, agentId, agentSecret, tmux) {
+    this.serverUrl = serverUrl;
+    this.agentId = agentId;
+    this.agentSecret = agentSecret;
+    this.tmux = tmux;
+  }
+  start() {
+    this.stopped = false;
+    this.connect();
+  }
+  stop() {
+    this.stopped = true;
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+    this.stopHeartbeat();
+    this.disposeAllBridges();
+    if (this.ws) {
+      this.ws.close(1e3, "agent shutting down");
+      this.ws = null;
+    }
+  }
+  connect() {
+    const wsUrl = buildWsUrl(this.serverUrl);
+    console.log(`[agent] Connecting to ${wsUrl}`);
+    const ws = new WebSocket(wsUrl);
+    this.ws = ws;
+    ws.on("open", () => {
+      console.log("[agent] WebSocket connected, authenticating...");
+      this.reconnectDelay = INITIAL_RECONNECT_DELAY_MS;
+      this.sendMessage({ type: "auth", agentId: this.agentId, agentSecret: this.agentSecret });
+    });
+    ws.on("message", (raw) => {
+      let msg;
+      try {
+        msg = JSON.parse(raw.toString());
+      } catch {
+        console.error("[agent] Failed to parse server message:", raw.toString());
+        return;
+      }
+      this.handleMessage(msg);
+    });
+    ws.on("close", (code, reason) => {
+      console.log(`[agent] WebSocket closed: code=${code} reason=${reason.toString()}`);
+      this.onDisconnect();
+    });
+    ws.on("error", (err) => {
+      console.error("[agent] WebSocket error:", err.message);
+    });
+  }
+  handleMessage(msg) {
+    switch (msg.type) {
+      case "auth-ok":
+        console.log("[agent] Authenticated successfully");
+        this.startHeartbeat();
+        this.syncSessions();
+        break;
+      case "auth-fail":
+        console.error(`[agent] Authentication failed: ${msg.message}`);
+        this.stopped = true;
+        if (this.ws) {
+          this.ws.close();
+          this.ws = null;
+        }
+        process.exit(1);
+        break;
+      case "sessions-list":
+        this.syncSessions();
+        break;
+      case "terminal-attach":
+        this.handleTerminalAttach(msg.browserId, msg.sessionName, msg.cols, msg.rows);
+        break;
+      case "terminal-detach":
+        this.handleTerminalDetach(msg.browserId);
+        break;
+      case "terminal-input":
+        this.handleTerminalInput(msg.browserId, msg.data);
+        break;
+      case "terminal-resize":
+        this.handleTerminalResize(msg.browserId, msg.cols, msg.rows);
+        break;
+      case "session-create":
+        this.handleSessionCreate(msg.name);
+        break;
+      case "session-kill":
+        this.handleSessionKill(msg.name);
+        break;
+      default:
+        console.warn("[agent] Unknown message type:", msg.type);
+    }
+  }
+  async syncSessions() {
+    try {
+      const sessions = await this.tmux.listSessions();
+      this.sendMessage({ type: "sessions-sync", sessions });
+    } catch (err) {
+      console.error("[agent] Failed to list sessions:", err);
+      this.sendMessage({ type: "error", message: "Failed to list sessions" });
+    }
+  }
+  async handleTerminalAttach(browserId, sessionName, cols, rows) {
+    const existing = this.bridges.get(browserId);
+    if (existing) {
+      existing.dispose();
+      this.bridges.delete(browserId);
+    }
+    try {
+      const bridge = await createTerminalBridge({
+        tmux: this.tmux,
+        sessionName,
+        cols,
+        rows,
+        onData: (data) => {
+          this.sendMessage({ type: "terminal-output", browserId, data });
+        },
+        onExit: (exitCode) => {
+          this.bridges.delete(browserId);
+          this.sendMessage({ type: "terminal-exit", browserId, exitCode });
+        }
+      });
+      this.bridges.set(browserId, bridge);
+      this.sendMessage({ type: "terminal-ready", browserId, sessionName });
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      console.error(`[agent] Failed to attach terminal for browser ${browserId}:`, message);
+      this.sendMessage({ type: "error", browserId, message: `Failed to attach: ${message}` });
+    }
+  }
+  handleTerminalDetach(browserId) {
+    const bridge = this.bridges.get(browserId);
+    if (bridge) {
+      bridge.dispose();
+      this.bridges.delete(browserId);
+    }
+  }
+  handleTerminalInput(browserId, data) {
+    const bridge = this.bridges.get(browserId);
+    if (bridge) {
+      bridge.write(data);
+    }
+  }
+  handleTerminalResize(browserId, cols, rows) {
+    const bridge = this.bridges.get(browserId);
+    if (bridge) {
+      bridge.resize(cols, rows);
+    }
+  }
+  async handleSessionCreate(name) {
+    try {
+      await this.tmux.createSession(name);
+      await this.syncSessions();
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      console.error(`[agent] Failed to create session "${name}":`, message);
+      this.sendMessage({ type: "error", message: `Failed to create session: ${message}` });
+    }
+  }
+  async handleSessionKill(name) {
+    try {
+      await this.tmux.killSession(name);
+      await this.syncSessions();
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      console.error(`[agent] Failed to kill session "${name}":`, message);
+      this.sendMessage({ type: "error", message: `Failed to kill session: ${message}` });
+    }
+  }
+  sendMessage(msg) {
+    if (this.ws && this.ws.readyState === WebSocket.OPEN) {
+      this.ws.send(JSON.stringify(msg));
+    }
+  }
+  startHeartbeat() {
+    this.stopHeartbeat();
+    this.heartbeatTimer = setInterval(() => {
+      this.sendMessage({ type: "heartbeat" });
+    }, HEARTBEAT_INTERVAL_MS);
+  }
+  stopHeartbeat() {
+    if (this.heartbeatTimer) {
+      clearInterval(this.heartbeatTimer);
+      this.heartbeatTimer = null;
+    }
+  }
+  disposeAllBridges() {
+    for (const [browserId, bridge] of this.bridges) {
+      bridge.dispose();
+      this.bridges.delete(browserId);
+    }
+  }
+  onDisconnect() {
+    this.stopHeartbeat();
+    this.disposeAllBridges();
+    this.ws = null;
+    if (this.stopped) {
+      return;
+    }
+    console.log(`[agent] Reconnecting in ${this.reconnectDelay}ms...`);
+    this.reconnectTimer = setTimeout(() => {
+      this.reconnectTimer = null;
+      this.connect();
+    }, this.reconnectDelay);
+    this.reconnectDelay = Math.min(this.reconnectDelay * 2, MAX_RECONNECT_DELAY_MS);
+  }
+};
+function buildWsUrl(serverUrl) {
+  const url = new URL("/ws/agent", serverUrl);
+  url.protocol = url.protocol === "https:" ? "wss:" : "ws:";
+  return url.toString();
+}
+
+// src/cli.ts
+var program = new Command();
+program.name("webmux-agent").description("Webmux agent \u2014 connects your machine to the webmux server").version("0.0.0");
+program.command("register").description("Register this agent with a webmux server").requiredOption("--server <url>", "Server URL (e.g. https://webmux.example.com)").requiredOption("--token <token>", "One-time registration token from the server").option("--name <name>", "Display name for this agent (defaults to hostname)").action(async (opts) => {
+  const serverUrl = opts.server.replace(/\/+$/, "");
+  const agentName = opts.name ?? os2.hostname();
+  console.log(`[agent] Registering with server ${serverUrl}...`);
+  console.log(`[agent] Agent name: ${agentName}`);
+  const body = {
+    token: opts.token,
+    name: agentName
+  };
+  let response;
+  try {
+    response = await fetch(`${serverUrl}/api/agents/register`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(body)
+    });
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    console.error(`[agent] Failed to connect to server: ${message}`);
+    process.exit(1);
+  }
+  if (!response.ok) {
+    let errorMessage;
+    try {
+      const errorBody = await response.json();
+      errorMessage = errorBody.error ?? response.statusText;
+    } catch {
+      errorMessage = response.statusText;
+    }
+    console.error(`[agent] Registration failed: ${errorMessage}`);
+    process.exit(1);
+  }
+  const result = await response.json();
+  saveCredentials({
+    serverUrl,
+    agentId: result.agentId,
+    agentSecret: result.agentSecret,
+    name: agentName
+  });
+  console.log(`[agent] Registration successful!`);
+  console.log(`[agent] Agent ID: ${result.agentId}`);
+  console.log(`[agent] Credentials saved to ${credentialsPath()}`);
+  console.log(`[agent] Run "webmux-agent start" to connect.`);
+});
+program.command("start").description("Start the agent and connect to the server").action(() => {
+  const creds = loadCredentials();
+  if (!creds) {
+    console.error(
+      `[agent] No credentials found at ${credentialsPath()}. Run "webmux-agent register" first.`
+    );
+    process.exit(1);
+  }
+  console.log(`[agent] Starting agent "${creds.name}"...`);
+  console.log(`[agent] Server: ${creds.serverUrl}`);
+  console.log(`[agent] Agent ID: ${creds.agentId}`);
+  const tmux = new TmuxClient({
+    socketName: "webmux",
+    workspaceRoot: process.cwd()
+  });
+  const connection = new AgentConnection(
+    creds.serverUrl,
+    creds.agentId,
+    creds.agentSecret,
+    tmux
+  );
+  const shutdown = () => {
+    console.log("\n[agent] Shutting down...");
+    connection.stop();
+    process.exit(0);
+  };
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
+  connection.start();
+});
+program.command("status").description("Show agent status and credentials info").action(() => {
+  const creds = loadCredentials();
+  if (!creds) {
+    console.log(`[agent] Not registered. No credentials found at ${credentialsPath()}.`);
+    process.exit(0);
+  }
+  console.log(`Agent Name:       ${creds.name}`);
+  console.log(`Server URL:       ${creds.serverUrl}`);
+  console.log(`Agent ID:         ${creds.agentId}`);
+  console.log(`Credentials File: ${credentialsPath()}`);
+});
+program.parse();

package/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "webmux-agent",
+  "version": "0.0.1",
+  "type": "module",
+  "bin": {
+    "webmux-agent": "./dist/cli.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "commander": "^14.0.0",
+    "node-pty": "^1.1.0",
+    "ws": "^8.19.0"
+  },
+  "devDependencies": {
+    "@types/ws": "^8.18.1",
+    "tsup": "^8.5.1",
+    "tsx": "^4.21.0",
+    "vitest": "^4.1.0",
+    "@webmux/shared": "0.0.0"
+  },
+  "scripts": {
+    "dev": "tsx src/cli.ts",
+    "build": "tsup",
+    "test": "vitest run"
+  }
+}