deskssh 0.1.2 → 0.1.9

package/dist/server.js

@@ -73,10 +73,11 @@ var TransparencyLog = class {
 };
 function withTransparency(executor, log, host) {
   return {
-    async exec(command) {
+    // `input` (e.g. a sudo password) is forwarded to the host but never logged.
+    async exec(command, input) {
       const startedAt = Date.now();
       try {
-        const result = await executor.exec(command);
+        const result = await executor.exec(command, input);
         log.record({
           command,
           host,
@@ -123,6 +124,35 @@ async function runParsed(executor, command, parser) {
   }
 }
 
+// ../core/dist/adapters/shell.js
+function quote(arg) {
+  return `'${arg.replace(/'/g, `'\\''`)}'`;
+}
+
+// ../core/dist/privilege/elevation.js
+function withElevation(executor, password) {
+  return {
+    exec(command) {
+      return executor.exec(`sudo -S -p '' sh -c ${quote(command)}`, `${password}
+`);
+    }
+  };
+}
+var SUDO_GROUPS = /* @__PURE__ */ new Set(["sudo", "wheel", "admin", "root"]);
+async function detectPrivilege(executor) {
+  const probe = 'echo "UID=$(id -u)"; echo "GROUPS=$(id -nG 2>/dev/null)"; command -v sudo >/dev/null 2>&1 && echo HAVE_SUDO; command -v su >/dev/null 2>&1 && echo HAVE_SU';
+  const { stdout } = await executor.exec(probe);
+  const isRoot = /UID=0\b/.test(stdout);
+  const groups = (/GROUPS=(.*)/.exec(stdout)?.[1] ?? "").trim().split(/\s+/).filter(Boolean);
+  const haveSudo = /\bHAVE_SUDO\b/.test(stdout);
+  const haveSu = /\bHAVE_SU\b/.test(stdout);
+  return {
+    isRoot,
+    canSudo: isRoot || haveSudo && groups.some((g) => SUDO_GROUPS.has(g)),
+    escalationAvailable: haveSudo || haveSu
+  };
+}
+
 // ../core/dist/adapters/os.js
 function parseOsRelease(raw) {
   const out = {};
@@ -172,11 +202,6 @@ async function detectOs(executor) {
   };
 }
 
-// ../core/dist/adapters/shell.js
-function quote(arg) {
-  return `'${arg.replace(/'/g, `'\\''`)}'`;
-}
-
 // ../core/dist/adapters/debian.js
 var FIND_PRINTF = String.raw`%y\t%s\t%m\t%u\t%g\t%T@\t%f\n`;
 var STAT_PRINTF = String.raw`%F\t%s\t%a\t%U\t%G\t%Y\t%n`;
@@ -287,6 +312,96 @@ function parseSystemMetrics(stdout) {
   };
 }
 var METRICS_COMMAND = "echo ===UPTIME===; cat /proc/uptime; echo ===LOAD===; cat /proc/loadavg; echo ===MEM===; cat /proc/meminfo";
+var PS_COMMAND = "ps -eo pid=,user=,pcpu=,pmem=,args=";
+function parseProcessLine(line) {
+  const m = /^\s*(\d+)\s+(\S+)\s+([\d.]+)\s+([\d.]+)\s+(.*)$/.exec(line);
+  if (!m)
+    throw new Error(`Unexpected ps output: ${line}`);
+  return {
+    pid: Number.parseInt(m[1] ?? "", 10) || 0,
+    user: m[2] ?? "",
+    cpu: Number.parseFloat(m[3] ?? "0") || 0,
+    mem: Number.parseFloat(m[4] ?? "0") || 0,
+    command: m[5] ?? ""
+  };
+}
+function parseProcesses(stdout) {
+  return stdout.split("\n").filter((line) => line.trim().length > 0).map(parseProcessLine);
+}
+var SYSINFO_COMMAND = [
+  "echo ===HOST===; hostname",
+  'echo ===OS===; . /etc/os-release 2>/dev/null; echo "$PRETTY_NAME"',
+  "echo ===KERNEL===; uname -r",
+  "echo ===UPTIME===; cat /proc/uptime",
+  'echo ===PKGS===; dpkg --list 2>/dev/null | grep -c "^ii"',
+  'echo ===SHELL===; echo "${SHELL##*/}"',
+  'echo ===CPU===; grep -m1 "model name" /proc/cpuinfo | cut -d: -f2; grep -c "^processor" /proc/cpuinfo',
+  'echo ===MEM===; grep -E "MemTotal|MemAvailable" /proc/meminfo',
+  "echo ===DISK===; df -P / | tail -1",
+  "echo ===IP===; hostname -I 2>/dev/null"
+].join("; ");
+function sectionsOf(stdout) {
+  const out = /* @__PURE__ */ new Map();
+  let current = "";
+  for (const line of stdout.split("\n")) {
+    const marker = /^===(\w+)===$/.exec(line);
+    if (marker?.[1]) {
+      current = marker[1];
+      out.set(current, []);
+    } else if (current) {
+      out.get(current)?.push(line);
+    }
+  }
+  return out;
+}
+function parseSystemInfo(stdout) {
+  const s = sectionsOf(stdout);
+  const line = (k, i = 0) => (s.get(k)?.[i] ?? "").trim();
+  const mem = /* @__PURE__ */ new Map();
+  for (const l of s.get("MEM") ?? []) {
+    const m = /^(\w+):\s+(\d+)\s*kB$/.exec(l.trim());
+    if (m?.[1] && m[2])
+      mem.set(m[1], Number.parseInt(m[2], 10) * 1024);
+  }
+  const memTotal = mem.get("MemTotal") ?? 0;
+  const memAvail = mem.get("MemAvailable") ?? 0;
+  const disk = line("DISK").split(/\s+/);
+  const ip = line("IP").split(/\s+/)[0] ?? "";
+  if (!line("HOST") && memTotal === 0)
+    throw new Error("Empty system-info output");
+  return {
+    hostname: line("HOST"),
+    prettyName: line("OS"),
+    kernel: line("KERNEL"),
+    uptimeSeconds: Math.round(Number.parseFloat(line("UPTIME").split(/\s+/)[0] ?? "0") || 0),
+    packages: Number.parseInt(line("PKGS"), 10) || 0,
+    shell: line("SHELL"),
+    cpuModel: line("CPU"),
+    cpuCount: Number.parseInt(line("CPU", 1), 10) || 1,
+    memTotalBytes: memTotal,
+    memUsedBytes: Math.max(0, memTotal - memAvail),
+    diskTotalBytes: (Number.parseInt(disk[1] ?? "0", 10) || 0) * 1024,
+    diskUsedBytes: (Number.parseInt(disk[2] ?? "0", 10) || 0) * 1024,
+    localIp: ip
+  };
+}
+function parseServiceState(name, stdout) {
+  const kv = /* @__PURE__ */ new Map();
+  for (const line of stdout.split("\n")) {
+    const eq = line.indexOf("=");
+    if (eq > 0)
+      kv.set(line.slice(0, eq), line.slice(eq + 1).trim());
+  }
+  const active = kv.get("ActiveState");
+  if (active === void 0)
+    throw new Error("Incomplete systemctl show output");
+  return {
+    name,
+    active: active === "active",
+    enabled: kv.get("UnitFileState") === "enabled",
+    status: kv.get("SubState") || active
+  };
+}
 var DebianAdapter = class {
   exec;
   constructor(exec) {
@@ -302,20 +417,62 @@ var DebianAdapter = class {
   async readFile(path) {
     return runParsed(this.exec, `base64 -w0 ${quote(path)}`, (b64) => Uint8Array.from(Buffer.from(b64.trim(), "base64")));
   }
-  async writeFile(path, contents) {
+  writeFile(path, contents) {
     const b64 = Buffer.from(contents).toString("base64");
-    const cmd = `printf %s ${quote(b64)} | base64 -d > ${quote(path)}`;
-    const { stderr, exitCode } = await this.exec.exec(cmd);
+    return this.runVoid(`printf %s ${quote(b64)} | base64 -d > ${quote(path)}`);
+  }
+  makeDir(path) {
+    return this.runVoid(`mkdir -p ${quote(path)}`);
+  }
+  createFile(path) {
+    return this.runVoid(`touch ${quote(path)}`);
+  }
+  move(from, to) {
+    return this.runVoid(`mv -n ${quote(from)} ${quote(to)}`);
+  }
+  copy(from, to) {
+    return this.runVoid(`cp -a -n ${quote(from)} ${quote(to)}`);
+  }
+  remove(path) {
+    return this.runVoid(`rm -rf ${quote(path)}`);
+  }
+  /** Run a command whose only outcome is success/failure (no parsed value). */
+  async runVoid(command) {
+    const { stdout, stderr, exitCode } = await this.exec.exec(command);
     if (exitCode !== 0) {
-      return { kind: "failed", raw: stderr, exitCode, reason: stderr.trim() || "write failed" };
+      return {
+        kind: "failed",
+        raw: stderr || stdout,
+        exitCode,
+        reason: stderr.trim() || "command failed"
+      };
     }
-    return ok(void 0, "");
+    return ok(void 0, stdout);
   }
   systemMetrics() {
     return runParsed(this.exec, METRICS_COMMAND, parseSystemMetrics);
   }
+  systemInfo() {
+    return runParsed(this.exec, SYSINFO_COMMAND, parseSystemInfo);
+  }
   listProcesses() {
-    return Promise.resolve(unsupported("listProcesses is a post-v1 capability"));
+    return runParsed(this.exec, PS_COMMAND, parseProcesses);
+  }
+  signalProcess(pid, signal) {
+    return this.runVoid(`kill -s ${signal} ${Math.trunc(pid)}`);
+  }
+  async serviceAction(name, action) {
+    const act = await this.exec.exec(`systemctl ${action} ${quote(name)}`);
+    if (act.exitCode !== 0) {
+      return {
+        kind: "failed",
+        raw: act.stderr || act.stdout,
+        exitCode: act.exitCode,
+        reason: act.stderr.trim() || `service ${action} failed`
+      };
+    }
+    const show = `systemctl show ${quote(name)} --property=ActiveState,UnitFileState,SubState`;
+    return runParsed(this.exec, show, (out) => parseServiceState(name, out));
   }
   listServices() {
     return Promise.resolve(unsupported("listServices is a post-v1 capability"));
@@ -330,8 +487,16 @@ function createUnsupportedAdapter(reason) {
     stat: fail,
     readFile: fail,
     writeFile: fail,
+    makeDir: fail,
+    createFile: fail,
+    move: fail,
+    copy: fail,
+    remove: fail,
     systemMetrics: fail,
+    systemInfo: fail,
     listProcesses: fail,
+    signalProcess: fail,
+    serviceAction: fail,
     listServices: fail
   };
 }
@@ -409,8 +574,10 @@ var SshSession = class _SshSession {
       }).connect(config);
     });
   }
-  /** Run a command, capturing stdout/stderr and the exit code (FR-030 building block). */
-  exec(command) {
+  /** Run a command, capturing stdout/stderr and the exit code (FR-030 building block).
+   *  `input`, when given, is written to stdin and stdin is closed (e.g. a password
+   *  for `sudo -S`); it is never part of the command string. */
+  exec(command, input) {
     return new Promise((resolve, reject) => {
       this.client.exec(command, (err, stream) => {
         if (err)
@@ -427,6 +594,8 @@ var SshSession = class _SshSession {
         stream.stderr.on("data", (chunk) => {
           stderr += chunk.toString("utf8");
         });
+        if (input !== void 0)
+          stream.end(input);
       });
     });
   }
@@ -440,9 +609,17 @@ var SshSession = class _SshSession {
       });
     });
   }
-  /** Open a PTY as a transport-agnostic {@link PtySession} (no ssh2 types leak). */
-  async openPty(cols = 80, rows = 24) {
+  /**
+   * Open a PTY as a transport-agnostic {@link PtySession} (no ssh2 types leak).
+   * When `cwd` is given the shell starts in that directory (e.g. "Open in
+   * terminal" from the file manager); the cd is issued as the first input and
+   * the screen cleared so the user sees a clean prompt.
+   */
+  async openPty(cols = 80, rows = 24, cwd) {
     const stream = await this.shell({ cols, rows, term: "xterm-256color" });
+    if (cwd)
+      stream.write(`cd ${quote(cwd)} 2>/dev/null; clear
+`);
     return {
       onData: (listener) => {
         stream.on("data", (chunk) => listener(chunk.toString("utf8")));
@@ -538,8 +715,10 @@ function createSshOpener(store) {
       home,
       os,
       adapter,
+      executor,
+      endpoint: { host: req.host, port: req.port ?? 22 },
       log,
-      openPty: (cols, rows) => session.openPty(cols, rows),
+      openPty: (cols, rows, cwd) => session.openPty(cols, rows, cwd),
       close: () => session.close()
     };
   };
@@ -597,17 +776,18 @@ function attachTerminal(server, manager) {
     if (url.pathname !== TERMINAL_PATH)
       return;
     const sessionId = url.searchParams.get("sessionId") ?? "";
+    const cwd = url.searchParams.get("cwd") ?? void 0;
     const entry = manager.get(sessionId);
     if (!entry?.openPty) {
       socket.destroy();
       return;
     }
-    wss.handleUpgrade(req, socket, head, (ws) => bridge(ws, entry.openPty));
+    wss.handleUpgrade(req, socket, head, (ws) => bridge(ws, entry.openPty, cwd));
   });
   return wss;
 }
-function bridge(ws, openPty) {
-  void openPty(80, 24).then((pty) => {
+function bridge(ws, openPty, cwd) {
+  void openPty(80, 24, cwd).then((pty) => {
     pty.onData((chunk) => {
       if (ws.readyState === ws.OPEN)
         ws.send(JSON.stringify({ type: "output", data: chunk }));
@@ -660,6 +840,27 @@ function serveStatic(dir, urlPath, res) {
   return true;
 }
 
+// ../server/dist/elevate.js
+async function makeElevated(entry, elevate) {
+  if (elevate.kind === "current") {
+    return {
+      adapter: selectAdapter(entry.os, withElevation(entry.executor, elevate.password)),
+      cleanup: () => {
+      }
+    };
+  }
+  const session = await SshSession.connect({
+    host: entry.endpoint.host,
+    port: entry.endpoint.port,
+    username: elevate.user,
+    auth: { kind: "password", password: elevate.password },
+    verifyHostKey: () => true
+  });
+  const exec = withTransparency(session, entry.log, `${elevate.user}@${entry.endpoint.host}`);
+  const executor = elevate.user === "root" ? exec : withElevation(exec, elevate.password);
+  return { adapter: selectAdapter(entry.os, executor), cleanup: () => session.close() };
+}
+
 // ../server/dist/gateway.js
 var MAX_BODY_BYTES = 1e6;
 var HttpError = class extends Error {
@@ -710,6 +911,38 @@ function asString(obj, key) {
   }
   return value;
 }
+function asOneOf(obj, key, allowed) {
+  const value = obj[key];
+  if (typeof value !== "string" || !allowed.includes(value)) {
+    throw new HttpError(400, `Invalid "${key}": expected one of ${allowed.join(", ")}`);
+  }
+  return value;
+}
+function parseElevate(value) {
+  if (value === void 0 || value === null)
+    return void 0;
+  if (typeof value !== "object")
+    throw new HttpError(400, 'Invalid "elevate"');
+  const o = value;
+  if (o["kind"] === "current" && typeof o["password"] === "string") {
+    return { kind: "current", password: o["password"] };
+  }
+  if (o["kind"] === "user" && typeof o["user"] === "string" && typeof o["password"] === "string") {
+    return { kind: "user", user: o["user"], password: o["password"] };
+  }
+  throw new HttpError(400, 'Invalid "elevate": expected { kind: "current"|"user", \u2026 }');
+}
+async function runCap(entry, body, call) {
+  const elevate = parseElevate(body["elevate"]);
+  if (!elevate)
+    return call(entry.adapter);
+  const { adapter, cleanup } = await makeElevated(entry, elevate);
+  try {
+    return await call(adapter);
+  } finally {
+    cleanup();
+  }
+}
 function createGateway(deps = {}) {
   const manager = deps.manager ?? new SessionManager();
   const opener = deps.opener ?? createSshOpener(new FileKnownHosts());
@@ -794,10 +1027,83 @@ async function handle(req, res, manager, opener, staticDir) {
   if (route === "POST /api/writefile") {
     const body = await readJsonBody(req);
     const entry = requireSession(manager, body);
-    const bytes = Buffer.from(asString(body, "base64"), "base64");
-    const result = await entry.adapter.writeFile(asString(body, "path"), new Uint8Array(bytes));
+    const bytes = new Uint8Array(Buffer.from(asString(body, "base64"), "base64"));
+    const path = asString(body, "path");
+    const result = await runCap(entry, body, (a) => a.writeFile(path, bytes));
     return sendJson(res, 200, { result });
   }
+  if (route === "POST /api/mkdir") {
+    const body = await readJsonBody(req);
+    const entry = requireSession(manager, body);
+    const path = asString(body, "path");
+    return sendJson(res, 200, { result: await runCap(entry, body, (a) => a.makeDir(path)) });
+  }
+  if (route === "POST /api/createfile") {
+    const body = await readJsonBody(req);
+    const entry = requireSession(manager, body);
+    const path = asString(body, "path");
+    return sendJson(res, 200, { result: await runCap(entry, body, (a) => a.createFile(path)) });
+  }
+  if (route === "POST /api/move") {
+    const body = await readJsonBody(req);
+    const entry = requireSession(manager, body);
+    const from = asString(body, "from");
+    const to = asString(body, "to");
+    return sendJson(res, 200, { result: await runCap(entry, body, (a) => a.move(from, to)) });
+  }
+  if (route === "POST /api/copy") {
+    const body = await readJsonBody(req);
+    const entry = requireSession(manager, body);
+    const from = asString(body, "from");
+    const to = asString(body, "to");
+    return sendJson(res, 200, { result: await runCap(entry, body, (a) => a.copy(from, to)) });
+  }
+  if (route === "POST /api/remove") {
+    const body = await readJsonBody(req);
+    const entry = requireSession(manager, body);
+    const path = asString(body, "path");
+    return sendJson(res, 200, { result: await runCap(entry, body, (a) => a.remove(path)) });
+  }
+  if (route === "POST /api/processes") {
+    const body = await readJsonBody(req);
+    const entry = requireSession(manager, body);
+    return sendJson(res, 200, { result: await entry.adapter.listProcesses() });
+  }
+  if (route === "POST /api/signal") {
+    const body = await readJsonBody(req);
+    const entry = requireSession(manager, body);
+    const pid = Number(body["pid"]);
+    if (!Number.isInteger(pid) || pid <= 0)
+      throw new HttpError(400, 'Invalid "pid"');
+    const signal = asOneOf(body, "signal", ["TERM", "KILL", "HUP"]);
+    return sendJson(res, 200, {
+      result: await runCap(entry, body, (a) => a.signalProcess(pid, signal))
+    });
+  }
+  if (route === "POST /api/service") {
+    const body = await readJsonBody(req);
+    const entry = requireSession(manager, body);
+    const name = asString(body, "name");
+    const action = asOneOf(body, "action", ["start", "stop", "restart"]);
+    return sendJson(res, 200, {
+      result: await runCap(entry, body, (a) => a.serviceAction(name, action))
+    });
+  }
+  if (route === "POST /api/privilege") {
+    const body = await readJsonBody(req);
+    const entry = requireSession(manager, body);
+    return sendJson(res, 200, { privilege: await detectPrivilege(entry.executor) });
+  }
+  if (route === "POST /api/systeminfo") {
+    const body = await readJsonBody(req);
+    const entry = requireSession(manager, body);
+    return sendJson(res, 200, { result: await entry.adapter.systemInfo() });
+  }
+  if (route === "POST /api/transparency") {
+    const body = await readJsonBody(req);
+    const entry = requireSession(manager, body);
+    return sendJson(res, 200, { transparency: entry.log.list() });
+  }
   sendJson(res, 404, { error: `No route for ${route}` });
 }
 function requireSession(manager, body) {