@webmux/agent 0.2.0 → 0.2.1

package/dist/chunk-EWE7ZUYJ.js

@@ -0,0 +1,163 @@
+#!/usr/bin/env node
+
+// 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, path] = parts;
+    const currentCommand = parts[6] ?? "";
+    if (!name || !windows || !attachedClients || !createdAt || !lastActivityAt || !path) {
+      return [];
+    }
+    return [
+      {
+        name,
+        windows: Number(windows),
+        attachedClients: Number(attachedClients),
+        createdAt: Number(createdAt),
+        lastActivityAt: Number(lastActivityAt),
+        path,
+        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));
+}
+
+export {
+  TmuxClient,
+  assertValidSessionName,
+  parseSessionList,
+  formatPreview,
+  isTmuxEmptyStateMessage
+};

package/dist/chunk-INUNCXBM.js

@@ -0,0 +1,202 @@
+#!/usr/bin/env node
+
+// src/service.ts
+import fs from "fs";
+import os from "os";
+import path from "path";
+import { execFileSync } from "child_process";
+var SERVICE_NAME = "webmux-agent";
+function renderServiceUnit(options) {
+  return `[Unit]
+Description=Webmux Agent (${options.agentName})
+After=network-online.target
+Wants=network-online.target
+
+[Service]
+Type=simple
+ExecStart=${options.nodePath} ${options.cliPath} start
+Restart=always
+RestartSec=10
+Environment=WEBMUX_AGENT_SERVICE=1
+Environment=WEBMUX_AGENT_AUTO_UPGRADE=${options.autoUpgrade ? "1" : "0"}
+Environment=WEBMUX_AGENT_NAME=${options.agentName}
+Environment=HOME=${options.homeDir}
+Environment=PATH=${options.pathEnv}
+WorkingDirectory=${options.homeDir}
+
+[Install]
+WantedBy=default.target
+`;
+}
+function installService(options) {
+  const homeDir = options.homeDir ?? os.homedir();
+  const autoUpgrade = options.autoUpgrade;
+  const release = installManagedRelease({
+    packageName: options.packageName,
+    version: options.version,
+    homeDir
+  });
+  writeServiceUnit({
+    agentName: options.agentName,
+    autoUpgrade,
+    cliPath: release.cliPath,
+    homeDir
+  });
+  runSystemctl(["--user", "daemon-reload"]);
+  runSystemctl(["--user", "enable", SERVICE_NAME]);
+  runSystemctl(["--user", "restart", SERVICE_NAME]);
+  runCommand("loginctl", ["enable-linger", os.userInfo().username]);
+}
+function upgradeService(options) {
+  const homeDir = options.homeDir ?? os.homedir();
+  const installedConfig = readInstalledServiceConfig(homeDir);
+  const autoUpgrade = options.autoUpgrade ?? installedConfig?.autoUpgrade ?? true;
+  const release = installManagedRelease({
+    packageName: options.packageName,
+    version: options.version,
+    homeDir
+  });
+  writeServiceUnit({
+    agentName: options.agentName,
+    autoUpgrade,
+    cliPath: release.cliPath,
+    homeDir
+  });
+  runSystemctl(["--user", "daemon-reload"]);
+  runSystemctl(["--user", "restart", SERVICE_NAME]);
+}
+function uninstallService(homeDir = os.homedir()) {
+  const unitPath = servicePath(homeDir);
+  try {
+    runSystemctl(["--user", "stop", SERVICE_NAME]);
+  } catch {
+  }
+  try {
+    runSystemctl(["--user", "disable", SERVICE_NAME]);
+  } catch {
+  }
+  if (fs.existsSync(unitPath)) {
+    fs.unlinkSync(unitPath);
+  }
+  try {
+    runSystemctl(["--user", "daemon-reload"]);
+  } catch {
+  }
+}
+function readInstalledServiceConfig(homeDir = os.homedir()) {
+  const unitPath = servicePath(homeDir);
+  if (!fs.existsSync(unitPath)) {
+    return null;
+  }
+  const unit = fs.readFileSync(unitPath, "utf-8");
+  const autoUpgradeMatch = unit.match(/^Environment=WEBMUX_AGENT_AUTO_UPGRADE=(\d)$/m);
+  const versionMatch = unit.match(/\/releases\/([^/\s]+)\/node_modules\//);
+  return {
+    autoUpgrade: autoUpgradeMatch?.[1] !== "0",
+    version: versionMatch?.[1] ?? null
+  };
+}
+function servicePath(homeDir = os.homedir()) {
+  return path.join(homeDir, ".config", "systemd", "user", `${SERVICE_NAME}.service`);
+}
+function writeServiceUnit(options) {
+  const serviceDir = path.dirname(servicePath(options.homeDir));
+  fs.mkdirSync(serviceDir, { recursive: true });
+  fs.writeFileSync(
+    servicePath(options.homeDir),
+    renderServiceUnit({
+      agentName: options.agentName,
+      autoUpgrade: options.autoUpgrade,
+      cliPath: options.cliPath,
+      homeDir: options.homeDir,
+      nodePath: findBinary("node") ?? process.execPath,
+      pathEnv: process.env.PATH ?? ""
+    })
+  );
+}
+function installManagedRelease(options) {
+  const releaseDir = path.join(options.homeDir, ".webmux", "releases", options.version);
+  const cliPath = path.join(
+    releaseDir,
+    "node_modules",
+    ...options.packageName.split("/"),
+    "dist",
+    "cli.js"
+  );
+  if (fs.existsSync(cliPath)) {
+    return { cliPath, releaseDir };
+  }
+  fs.mkdirSync(releaseDir, { recursive: true });
+  ensureRuntimePackageJson(releaseDir);
+  const packageManager = findBinary("pnpm") ? "pnpm" : "npm";
+  if (packageManager === "pnpm") {
+    runCommand("pnpm", ["add", "--dir", releaseDir, `${options.packageName}@${options.version}`]);
+  } else {
+    if (!findBinary("npm")) {
+      throw new Error("Cannot find pnpm or npm. Install one package manager before installing the service.");
+    }
+    runCommand("npm", ["install", "--omit=dev", `${options.packageName}@${options.version}`], releaseDir);
+  }
+  if (!fs.existsSync(cliPath)) {
+    throw new Error(`Managed release did not produce a CLI at ${cliPath}`);
+  }
+  return { cliPath, releaseDir };
+}
+function ensureRuntimePackageJson(releaseDir) {
+  const packageJsonPath = path.join(releaseDir, "package.json");
+  if (fs.existsSync(packageJsonPath)) {
+    return;
+  }
+  fs.writeFileSync(
+    packageJsonPath,
+    JSON.stringify({
+      name: "webmux-agent-runtime",
+      private: true
+    }, null, 2) + "\n"
+  );
+}
+function runSystemctl(args) {
+  runCommand("systemctl", args);
+}
+function runCommand(command, args, cwd) {
+  execFileSync(command, args, {
+    cwd,
+    stdio: "inherit"
+  });
+}
+function findBinary(name) {
+  try {
+    return execFileSync("which", [name], { encoding: "utf-8" }).trim();
+  } catch {
+    return null;
+  }
+}
+
+// src/version.ts
+import fs2 from "fs";
+var packageMetadata = readAgentPackageMetadata();
+var AGENT_PACKAGE_NAME = packageMetadata.name;
+var AGENT_VERSION = packageMetadata.version;
+function readAgentPackageMetadata() {
+  const packageJsonPath = new URL("../package.json", import.meta.url);
+  const raw = fs2.readFileSync(packageJsonPath, "utf-8");
+  const parsed = JSON.parse(raw);
+  if (!parsed.name || !parsed.version) {
+    throw new Error("Agent package metadata is missing name or version");
+  }
+  return {
+    name: parsed.name,
+    version: parsed.version
+  };
+}
+
+export {
+  SERVICE_NAME,
+  installService,
+  upgradeService,
+  uninstallService,
+  readInstalledServiceConfig,
+  servicePath,
+  AGENT_PACKAGE_NAME,
+  AGENT_VERSION
+};