tmuxes 0.1.8 → 0.1.9

package/server/src/validate.ts

@@ -0,0 +1,79 @@
+/**
+ * Allowlist validation. Every value that reaches a spawned tmux/ssh argv is
+ * checked here first. We never spawn a shell (argv arrays + shell:false), so
+ * this is defense-in-depth, but it also keeps tmux target syntax sane.
+ */
+
+// '.' and ':' are tmux target delimiters (session:window.pane) — forbidden in names.
+const SESSION_NAME_RE = /^[A-Za-z0-9_-]{1,64}$/;
+const HOST_RE = /^[A-Za-z0-9._-]{1,255}$/;
+const USER_RE = /^[A-Za-z0-9._-]{1,64}$/;
+// ssh_config Host aliases: word chars, dots, hyphens (no wildcards/spaces).
+const HOST_ALIAS_RE = /^[A-Za-z0-9._-]{1,255}$/;
+
+export function isValidSessionName(name: unknown): name is string {
+  return typeof name === 'string' && SESSION_NAME_RE.test(name);
+}
+
+export function isValidHost(host: unknown): host is string {
+  return typeof host === 'string' && HOST_RE.test(host);
+}
+
+export function isValidUser(user: unknown): user is string {
+  return typeof user === 'string' && USER_RE.test(user);
+}
+
+export function isValidHostAlias(alias: unknown): alias is string {
+  return typeof alias === 'string' && HOST_ALIAS_RE.test(alias);
+}
+
+export function isValidPort(port: unknown): port is number {
+  return (
+    typeof port === 'number' &&
+    Number.isInteger(port) &&
+    port >= 1 &&
+    port <= 65535
+  );
+}
+
+/** Terminal geometry sent by clients. */
+export function isValidDimension(n: unknown): n is number {
+  return typeof n === 'number' && Number.isInteger(n) && n >= 1 && n <= 1000;
+}
+
+export interface HostSpec {
+  user?: string;
+  host: string;
+  port?: number;
+}
+
+/**
+ * Parse a "user@host:port" spec (used by the TMUXES_HOSTS env override).
+ * Returns null if any component is invalid.
+ */
+export function parseHostSpec(spec: string): HostSpec | null {
+  const trimmed = spec.trim();
+  if (!trimmed) return null;
+
+  let user: string | undefined;
+  let rest = trimmed;
+  const at = rest.indexOf('@');
+  if (at !== -1) {
+    user = rest.slice(0, at);
+    rest = rest.slice(at + 1);
+    if (!isValidUser(user)) return null;
+  }
+
+  let port: number | undefined;
+  const colon = rest.indexOf(':');
+  if (colon !== -1) {
+    const portStr = rest.slice(colon + 1);
+    rest = rest.slice(0, colon);
+    const parsed = Number(portStr);
+    if (!isValidPort(parsed)) return null;
+    port = parsed;
+  }
+
+  if (!isValidHost(rest)) return null;
+  return { user, host: rest, port };
+}

package/server/src/windowsSsh.ts

@@ -0,0 +1,239 @@
+import { spawn, type ChildProcessWithoutNullStreams } from 'node:child_process';
+import { randomUUID } from 'node:crypto';
+import type { CommandResult, RunOptions } from './exec.js';
+import { config } from './config.js';
+import { sshDestination, type Target } from './targets.js';
+import { sshClientArgs } from './tmux/builder.js';
+
+interface RemoteCommand {
+  command: string;
+  input?: string;
+}
+
+interface PendingCommand {
+  id: string;
+  resolve: (result: CommandResult) => void;
+  timer?: NodeJS.Timeout;
+}
+
+const SENSITIVE_SSH_OPTIONS = new Set([
+  '-B',
+  '-b',
+  '-c',
+  '-D',
+  '-E',
+  '-e',
+  '-F',
+  '-I',
+  '-i',
+  '-J',
+  '-L',
+  '-l',
+  '-m',
+  '-O',
+  '-o',
+  '-p',
+  '-Q',
+  '-R',
+  '-S',
+  '-W',
+  '-w',
+]);
+
+const sessions = new Map<string, WindowsSshSession>();
+
+function targetKey(target: Target): string {
+  return `${sshDestination(target)}:${target.port ?? 22}:${target.id}`;
+}
+
+function splitSshArgs(args: string[]): { connectArgs: string[]; remoteArgs: string[] } {
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (SENSITIVE_SSH_OPTIONS.has(arg)) {
+      i++;
+      continue;
+    }
+    if (arg.startsWith('-')) continue;
+    return { connectArgs: args.slice(0, i + 1), remoteArgs: args.slice(i + 1) };
+  }
+  return { connectArgs: args, remoteArgs: [] };
+}
+
+function commandFromSshArgv(file: string, args: string[], input?: string): RemoteCommand {
+  if (file !== 'ssh') return { command: '', input };
+  const { remoteArgs } = splitSshArgs(args);
+  return { command: remoteArgs.join(' '), input };
+}
+
+function connectArgsFor(target: Target): string[] {
+  const argv = sshClientArgs(target, {
+    batchMode: true,
+    connectTimeout: config.ssh.connectTimeoutMgmt,
+    multiplex: false,
+  });
+  const { connectArgs } = splitSshArgs(argv.slice(1));
+  return ['-T', ...connectArgs, 'sh'];
+}
+
+function encodeInput(input: string): string {
+  return Buffer.from(input, 'utf8').toString('base64').replace(/(.{76})/g, '$1\n');
+}
+
+function decodePayload(payload: string): string {
+  return Buffer.from(payload.replace(/\s+/g, ''), 'base64').toString('utf8');
+}
+
+function scriptFor(id: string, command: string, input?: string): string {
+  const inputMarker = `__TMUXES_INPUT_${id}__`;
+  const begin = `__TMUXES_BEGIN_${id}__`;
+  const stderr = `__TMUXES_STDERR_${id}__`;
+  const end = `__TMUXES_END_${id}__`;
+  const run = input === undefined
+    ? `( ${command} )`
+    : `base64 -d <<'${inputMarker}' | ( ${command} )\n${encodeInput(input)}\n${inputMarker}`;
+
+  return [
+    `__tmuxes_out=$(mktemp "\${TMPDIR:-/tmp}/tmuxes-out.XXXXXX") || exit 125`,
+    `__tmuxes_err=$(mktemp "\${TMPDIR:-/tmp}/tmuxes-err.XXXXXX") || { rm -f "$__tmuxes_out"; exit 125; }`,
+    `{ ${run}\n} > "$__tmuxes_out" 2> "$__tmuxes_err"`,
+    `__tmuxes_code=$?`,
+    `printf '\\n${begin}\\n'`,
+    `printf '%s\\n' "$__tmuxes_code"`,
+    `base64 < "$__tmuxes_out"`,
+    `printf '\\n${stderr}\\n'`,
+    `base64 < "$__tmuxes_err"`,
+    `printf '\\n${end}\\n'`,
+    `rm -f "$__tmuxes_out" "$__tmuxes_err"`,
+  ].join('\n') + '\n';
+}
+
+class WindowsSshSession {
+  private readonly child: ChildProcessWithoutNullStreams;
+  private queue: Promise<void> = Promise.resolve();
+  private stdout = '';
+  private sshStderr = '';
+  private closed = false;
+  private pending?: PendingCommand;
+
+  constructor(
+    private readonly key: string,
+    target: Target,
+  ) {
+    this.child = spawn('ssh', connectArgsFor(target), { shell: false });
+    this.child.stdout.on('data', (chunk: Buffer) => this.onStdout(chunk.toString('utf8')));
+    this.child.stderr.on('data', (chunk: Buffer) => {
+      this.sshStderr += chunk.toString('utf8');
+    });
+    this.child.on('error', (err) => this.finishPending(null, null, err.message));
+    this.child.on('close', (code, signal) => {
+      this.closed = true;
+      if (sessions.get(this.key) === this) sessions.delete(this.key);
+      this.finishPending(code, signal, this.sshStderr || 'ssh connection closed');
+    });
+  }
+
+  dispose(): void {
+    this.closed = true;
+    if (sessions.get(this.key) === this) sessions.delete(this.key);
+    try {
+      this.child.kill('SIGKILL');
+    } catch {
+      /* already gone */
+    }
+  }
+
+  run(command: string, input: string | undefined, opts: RunOptions): Promise<CommandResult> {
+    const next = this.queue
+      .catch(() => {
+        /* keep later commands moving */
+      })
+      .then(() => this.runNow(command, input, opts));
+    this.queue = next.then(
+      () => undefined,
+      () => undefined,
+    );
+    return next;
+  }
+
+  private runNow(command: string, input: string | undefined, opts: RunOptions): Promise<CommandResult> {
+    if (this.closed) return Promise.resolve({ code: 255, signal: null, stdout: '', stderr: 'ssh connection closed' });
+    if (!command) return Promise.resolve({ code: 255, signal: null, stdout: '', stderr: 'missing remote command' });
+
+    const id = randomUUID().replace(/-/g, '');
+    return new Promise((resolve) => {
+      const pending: PendingCommand = { id, resolve };
+      this.pending = pending;
+      if (opts.timeoutMs) {
+        pending.timer = setTimeout(() => {
+          this.resolvePending({ code: null, signal: 'SIGKILL', stdout: '', stderr: 'ssh command timed out' });
+          this.dispose();
+        }, opts.timeoutMs);
+      }
+
+      this.child.stdin.write(scriptFor(id, command, input), (err) => {
+        if (err) this.finishPending(null, null, err.message);
+      });
+    });
+  }
+
+  private onStdout(chunk: string): void {
+    this.stdout += chunk;
+    const pending = this.pending;
+    if (!pending) return;
+
+    const begin = `__TMUXES_BEGIN_${pending.id}__\n`;
+    const stderr = `\n__TMUXES_STDERR_${pending.id}__\n`;
+    const end = `\n__TMUXES_END_${pending.id}__`;
+    const beginIndex = this.stdout.indexOf(begin);
+    if (beginIndex < 0) return;
+    const stderrIndex = this.stdout.indexOf(stderr, beginIndex + begin.length);
+    if (stderrIndex < 0) return;
+    const endIndex = this.stdout.indexOf(end, stderrIndex + stderr.length);
+    if (endIndex < 0) return;
+
+    const stdoutStart = beginIndex + begin.length;
+    const codeLineEnd = this.stdout.indexOf('\n', stdoutStart);
+    if (codeLineEnd < 0 || codeLineEnd > stderrIndex) return;
+
+    const code = Number(this.stdout.slice(stdoutStart, codeLineEnd)) || 0;
+    const out = decodePayload(this.stdout.slice(codeLineEnd + 1, stderrIndex));
+    const err = decodePayload(this.stdout.slice(stderrIndex + stderr.length, endIndex));
+    this.stdout = this.stdout.slice(endIndex + end.length);
+    this.resolvePending({ code, signal: null, stdout: out, stderr: err });
+  }
+
+  private resolvePending(result: CommandResult): void {
+    const pending = this.pending;
+    if (!pending) return;
+    this.pending = undefined;
+    if (pending.timer) clearTimeout(pending.timer);
+    pending.resolve(result);
+  }
+
+  private finishPending(code: number | null, signal: NodeJS.Signals | null, stderr: string): void {
+    this.resolvePending({ code, signal, stdout: '', stderr });
+  }
+}
+
+function sessionFor(target: Target): WindowsSshSession {
+  const key = targetKey(target);
+  const existing = sessions.get(key);
+  if (existing) return existing;
+  const session = new WindowsSshSession(key, target);
+  sessions.set(key, session);
+  return session;
+}
+
+export async function runWindowsSshCommand(
+  target: Target,
+  file: string,
+  args: string[],
+  opts: RunOptions,
+): Promise<CommandResult> {
+  const { command, input } = commandFromSshArgv(file, args, opts.input);
+  return sessionFor(target).run(command, input, opts);
+}
+
+export function dropWindowsSshSession(target: Target): void {
+  sessions.get(targetKey(target))?.dispose();
+}

package/server/src/winshell/manager.ts

@@ -0,0 +1,296 @@
+import * as pty from 'node-pty';
+import { existsSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { isWindows } from '../platform.js';
+import { log } from '../logger.js';
+import type { ServerControl } from '../ws/protocol.js';
+import type { SessionInfo, WindowInfo } from '../tmux/formats.js';
+
+/** A definition of a launchable shell. */
+export interface ShellDef {
+  id: string;
+  label: string;
+  file: string;
+  args: string[];
+}
+
+/** What the manager needs from an attached WebSocket — kept abstract so the
+ *  session logic is testable without a real socket. */
+export interface ShellClient {
+  id: number;
+  sendBinary(buf: Buffer): void;
+  sendControl(msg: ServerControl): void;
+  isOpen(): boolean;
+  close(code: number, reason: string): void;
+}
+
+const SCROLLBACK_CAP = 256 * 1024; // bytes of history replayed to a new client
+
+function nowEpoch(): number {
+  return Math.floor(Date.now() / 1000);
+}
+
+/** One persistent native shell (its own pty), shared by 0..N attached clients.
+ *  Survives client disconnects (the pty lives until killed or it exits), which
+ *  is what gives "refresh / reconnect / multi-tab" persistence. */
+export class WinShellSession {
+  readonly created = nowEpoch();
+  private clients = new Set<ShellClient>();
+  private scroll: Buffer[] = [];
+  private scrollBytes = 0;
+  private disposed = false;
+  /** epoch seconds of last pty output — drives idle/attention detection */
+  private lastActivity = nowEpoch();
+
+  constructor(
+    public name: string,
+    readonly shell: ShellDef,
+    private readonly ptyProc: pty.IPty,
+    private readonly onClosed: (name: string) => void,
+  ) {
+    this.ptyProc.onData((d) => this.onData(d));
+    this.ptyProc.onExit(({ exitCode }) => this.onExit(exitCode));
+  }
+
+  get attached(): boolean {
+    return this.clients.size > 0;
+  }
+
+  private onData(data: string): void {
+    this.lastActivity = nowEpoch();
+    const buf = Buffer.from(data, 'utf8');
+    this.scroll.push(buf);
+    this.scrollBytes += buf.length;
+    while (this.scrollBytes > SCROLLBACK_CAP && this.scroll.length > 1) {
+      this.scrollBytes -= this.scroll.shift()!.length;
+    }
+    for (const c of this.clients) if (c.isOpen()) c.sendBinary(buf);
+  }
+
+  private onExit(code: number | null): void {
+    if (this.disposed) return;
+    this.disposed = true;
+    for (const c of this.clients) {
+      c.sendControl({ type: 'exit', code });
+      c.close(1000, 'shell exited');
+    }
+    this.clients.clear();
+    this.onClosed(this.name);
+  }
+
+  /** Add a client: replay history, then it's live. Caller sends `ready` after. */
+  attach(client: ShellClient): void {
+    if (this.scroll.length) client.sendBinary(Buffer.concat(this.scroll));
+    this.clients.add(client);
+  }
+
+  detach(client: ShellClient): void {
+    this.clients.delete(client); // pty stays alive — persistence across reconnects
+  }
+
+  write(data: string): void {
+    if (!this.disposed) this.ptyProc.write(data);
+  }
+
+  resize(cols: number, rows: number): void {
+    try {
+      this.ptyProc.resize(cols, rows);
+    } catch {
+      /* pty may have exited */
+    }
+  }
+
+  info(): SessionInfo {
+    return {
+      name: this.name,
+      windows: 1,
+      attached: this.attached,
+      created: this.created,
+      lastActivity: this.lastActivity,
+    };
+  }
+
+  dispose(): void {
+    if (this.disposed) {
+      this.onClosed(this.name);
+      return;
+    }
+    this.disposed = true;
+    try {
+      this.ptyProc.kill();
+    } catch {
+      /* already gone */
+    }
+    for (const c of this.clients) c.close(1000, 'killed');
+    this.clients.clear();
+    this.onClosed(this.name);
+  }
+}
+
+const NAME_RE = /^[A-Za-z0-9_-]{1,64}$/;
+
+/** Owns all native shell sessions for the local Windows machine. */
+export class WinShellManager {
+  private sessions = new Map<string, WinShellSession>();
+  private shells: ShellDef[];
+
+  constructor(shells?: ShellDef[]) {
+    this.shells = shells ?? detectShells();
+  }
+
+  listShells(): { id: string; label: string }[] {
+    return this.shells.map((s) => ({ id: s.id, label: s.label }));
+  }
+
+  private resolveShell(shellId?: string): ShellDef {
+    if (shellId) {
+      const found = this.shells.find((s) => s.id === shellId);
+      if (found) return found;
+    }
+    if (this.shells.length === 0) throw new Error('no shell available');
+    return this.shells[0];
+  }
+
+  list(): SessionInfo[] {
+    return [...this.sessions.values()]
+      .map((s) => s.info())
+      .sort((a, b) => a.created - b.created);
+  }
+
+  windows(name: string): WindowInfo[] {
+    const s = this.sessions.get(name);
+    if (!s) return [];
+    return [{ index: 0, name: s.shell.label, panes: 1, active: true }];
+  }
+
+  has(name: string): boolean {
+    return this.sessions.has(name);
+  }
+
+  private autoName(shell: ShellDef): string {
+    for (let i = 1; i < 10000; i++) {
+      const candidate = `${shell.id}-${i}`;
+      if (!this.sessions.has(candidate)) return candidate;
+    }
+    return `${shell.id}-${nowEpoch()}`;
+  }
+
+  /** Create a new shell session. Returns the (possibly auto-assigned) name. */
+  create(opts: { name?: string; shellId?: string; command?: string; cols?: number; rows?: number }): {
+    name: string;
+  } {
+    const shell = this.resolveShell(opts.shellId);
+    const name = opts.name ?? this.autoName(shell);
+    if (!NAME_RE.test(name)) throw new ManagerError(400, 'invalid session name');
+    if (this.sessions.has(name)) throw new ManagerError(409, `session "${name}" already exists`);
+
+    const cols = opts.cols ?? 80;
+    const rows = opts.rows ?? 24;
+    let proc: pty.IPty;
+    try {
+      proc = pty.spawn(shell.file, shell.args, {
+        name: 'xterm-256color',
+        cols,
+        rows,
+        cwd: homedir(),
+        env: { ...process.env, TERM: 'xterm-256color' },
+      });
+    } catch (e) {
+      throw new ManagerError(502, `failed to start ${shell.label}: ${(e as Error).message}`);
+    }
+
+    const session = new WinShellSession(name, shell, proc, (n) => this.sessions.delete(n));
+    this.sessions.set(name, session);
+    if (opts.command && opts.command.length > 0) session.write(`${opts.command}\r`);
+    log.info(`winshell created ${name} (${shell.label})`);
+    return { name };
+  }
+
+  rename(oldName: string, newName: string): void {
+    if (!NAME_RE.test(newName)) throw new ManagerError(400, 'invalid new session name');
+    const s = this.sessions.get(oldName);
+    if (!s) throw new ManagerError(404, `session "${oldName}" not found`);
+    if (this.sessions.has(newName)) throw new ManagerError(409, `session "${newName}" already exists`);
+    // Re-key the same live instance (its pty handlers read `this.name`).
+    this.sessions.delete(oldName);
+    s.name = newName;
+    this.sessions.set(newName, s);
+  }
+
+  kill(name: string): void {
+    const s = this.sessions.get(name);
+    if (!s) throw new ManagerError(404, `session "${name}" not found`);
+    s.dispose();
+  }
+
+  /** Attach a client to an existing session, creating it (default shell) if missing. */
+  attachOrCreate(name: string, cols: number, rows: number, client: ShellClient): WinShellSession {
+    let s = this.sessions.get(name);
+    if (!s) {
+      this.create({ name, cols, rows });
+      s = this.sessions.get(name)!;
+    } else {
+      s.resize(cols, rows);
+    }
+    s.attach(client);
+    return s;
+  }
+
+  disposeAll(): void {
+    for (const s of [...this.sessions.values()]) s.dispose();
+  }
+}
+
+/** Manager error carrying an HTTP status for the router. */
+export class ManagerError extends Error {
+  constructor(
+    public status: number,
+    message: string,
+  ) {
+    super(message);
+    this.name = 'ManagerError';
+  }
+}
+
+/** Detect launchable shells for this machine. Windows: PowerShell 7 (if on
+ *  PATH) → Windows PowerShell → cmd → Git Bash. Otherwise (test/fake): the
+ *  user's shell, so the whole path can be exercised on Linux. */
+export function detectShells(): ShellDef[] {
+  if (!isWindows) {
+    const file = process.env.SHELL || '/bin/bash';
+    return [{ id: 'shell', label: file.split('/').pop() || 'shell', file, args: ['-i'] }];
+  }
+
+  const shells: ShellDef[] = [];
+  const sysRoot = process.env.SystemRoot || process.env.windir || 'C:\\Windows';
+
+  const pwsh = findOnPath('pwsh.exe');
+  if (pwsh) shells.push({ id: 'pwsh', label: 'PowerShell 7', file: pwsh, args: ['-NoLogo'] });
+
+  const winPs = join(sysRoot, 'System32', 'WindowsPowerShell', 'v1.0', 'powershell.exe');
+  if (existsSync(winPs)) shells.push({ id: 'powershell', label: 'Windows PowerShell', file: winPs, args: ['-NoLogo'] });
+
+  const cmd = join(sysRoot, 'System32', 'cmd.exe');
+  if (existsSync(cmd)) shells.push({ id: 'cmd', label: 'Command Prompt', file: cmd, args: [] });
+
+  const gitBash = 'C:\\Program Files\\Git\\bin\\bash.exe';
+  if (existsSync(gitBash)) shells.push({ id: 'gitbash', label: 'Git Bash', file: gitBash, args: ['-i', '-l'] });
+
+  // Last-resort fallback so the target is never shell-less.
+  if (shells.length === 0) shells.push({ id: 'cmd', label: 'Command Prompt', file: 'cmd.exe', args: [] });
+  return shells;
+}
+
+function findOnPath(exe: string): string | null {
+  const dirs = (process.env.PATH || '').split(isWindows ? ';' : ':');
+  for (const dir of dirs) {
+    if (!dir) continue;
+    const candidate = join(dir, exe);
+    if (existsSync(candidate)) return candidate;
+  }
+  return null;
+}
+
+/** Singleton used by the REST and WS layers. */
+export const winShell = new WinShellManager();

package/server/src/ws/protocol.ts

@@ -0,0 +1,15 @@
+/** Shared WebSocket control-message types. Terminal bytes travel as BINARY
+ *  frames; everything below travels as TEXT (JSON) frames. */
+
+export type SshState = 'hostkey' | 'authfail' | 'refused' | 'timeout';
+
+export type ClientControl =
+  | { type: 'resize'; cols: number; rows: number }
+  | { type: 'ping' };
+
+export type ServerControl =
+  | { type: 'ready'; target: string; session: string }
+  | { type: 'ssh'; state: SshState; message: string }
+  | { type: 'error'; message: string }
+  | { type: 'exit'; code: number | null }
+  | { type: 'pong' };

package/server/src/ws/sshState.ts

@@ -0,0 +1,36 @@
+import type { SshState } from './protocol.js';
+
+/**
+ * Classify ssh failure/prompt states from PTY output so the UI can show
+ * something better than a black screen. Best-effort string matching on the
+ * raw ssh client output.
+ */
+const MATCHERS: { state: SshState; re: RegExp; message: string }[] = [
+  {
+    state: 'hostkey',
+    re: /authenticity of host|fingerprint|known_hosts|REMOTE HOST IDENTIFICATION HAS CHANGED/i,
+    message: 'Unknown or changed host key — verify the host in a regular terminal first.',
+  },
+  {
+    state: 'authfail',
+    re: /permission denied|too many authentication failures|no such identity|authentication failed/i,
+    message: 'SSH authentication failed — check your keys / ssh-agent.',
+  },
+  {
+    state: 'refused',
+    re: /connection refused|could not resolve hostname|name or service not known|no route to host/i,
+    message: 'Could not connect to the host (refused / unresolved).',
+  },
+  {
+    state: 'timeout',
+    re: /connection timed out|operation timed out|timed out waiting/i,
+    message: 'Connection timed out.',
+  },
+];
+
+export function classifySsh(text: string): { state: SshState; message: string } | null {
+  for (const m of MATCHERS) {
+    if (m.re.test(text)) return { state: m.state, message: m.message };
+  }
+  return null;
+}