server.ts

import { Client, type ConnectConfig } from 'ssh2';
import { readdirSync, statSync, readFileSync, writeFileSync, unlinkSync, createWriteStream, mkdirSync } from 'fs';
import { join, dirname, basename } from 'path';
import { homedir, tmpdir } from 'os';
import { spawn } from 'child_process';
import { randomUUID } from 'crypto';
import { createServer as createNetServer } from 'net';

// ─── Types ─────────────────────────────────────────────────────────
interface FileEntry {
  name: string;
  type: 'directory' | 'file';
  size: number;
  modified: string;
}

interface ConnInfo {
  host: string;
  username: string;
  port: number;
}

interface TransferState {
  status: 'running' | 'cancelled';
  process?: ReturnType<typeof spawn>;
}

interface SavedConnection {
  id: string;
  name: string;
  host: string;
  port: number;
  username: string;
  authMode: 'password' | 'key' | 'default';
  privateKeyPath?: string;
}

interface Snippet {
  id: string;
  label: string;
  command: string;
}

interface PortForward {
  id: string;
  localPort: number;
  remoteHost: string;
  remotePort: number;
  server: ReturnType<typeof createNetServer>;
  connCount: number;
}

// ─── Module state ──────────────────────────────────────────────────
let sshClient: Client | null = null;
let connInfo: ConnInfo | null = null;
const transferMap = new Map<string, TransferState>();
const forwardMap = new Map<string, PortForward>();
const wsSet = new Set<import('bun').ServerWebSocket<unknown>>();
const CONNECTIONS_FILE = join(homedir(), '.serverbrdg.json');

// ─── Exported utilities ─────────────────────────────────────────────

export function formatBytes(bytes: number): string {
  if (!bytes) return '—';
  const units = ['B', 'KB', 'MB', 'GB', 'TB'];
  const i = Math.floor(Math.log(bytes) / Math.log(1024));
  return `${(bytes / 1024 ** i).toFixed(1)} ${units[i]}`;
}

export function parseRsyncProgress(line: string): { percent: number; speed: string; eta: string } | null {
  const m = line.match(/[\d,]+\s+(\d+)%\s+([\d.]+[kMGT]?B\/s)\s+([\d:]+)/);
  if (!m) return null;
  return { percent: parseInt(m[1]), speed: m[2], eta: m[3] };
}

// ─── Saved connections & snippets ──────────────────────────────────

function loadDataFile(): { connections: SavedConnection[]; snippets: Snippet[] } {
  try {
    const d = JSON.parse(readFileSync(CONNECTIONS_FILE, 'utf8'));
    return { connections: d.connections ?? [], snippets: d.snippets ?? [] };
  } catch { return { connections: [], snippets: [] }; }
}

function loadConnections(): SavedConnection[] { return loadDataFile().connections; }
function loadSnippets(): Snippet[] { return loadDataFile().snippets; }

function saveConnections(conns: SavedConnection[]) {
  const d = loadDataFile();
  writeFileSync(CONNECTIONS_FILE, JSON.stringify({ ...d, connections: conns }, null, 2));
}

function saveSnippets(snippets: Snippet[]) {
  const d = loadDataFile();
  writeFileSync(CONNECTIONS_FILE, JSON.stringify({ ...d, snippets }, null, 2));
}

// ─── Internal helpers ──────────────────────────────────────────────

function jsonResp(data: object, status = 200): Response {
  return new Response(JSON.stringify(data), {
    status,
    headers: { 'Content-Type': 'application/json' }
  });
}

function broadcast(data: object) {
  const msg = JSON.stringify(data);
  for (const ws of wsSet) ws.send(msg);
}

// ─── Request router ────────────────────────────────────────────────

async function handleRequest(req: Request, server: import('bun').Server): Promise<Response> {
  const url = new URL(req.url);
  const { method } = req;
  const p = url.pathname;

  if (p === '/ws') {
    return server.upgrade(req, { data: { type: 'progress' } }) ? (undefined as any) : new Response('Upgrade failed', { status: 400 });
  }
  if (p === '/ws/terminal') {
    if (!sshClient) return new Response('Not connected', { status: 400 });
    return server.upgrade(req, { data: { type: 'terminal', channel: null as any } }) ? (undefined as any) : new Response('Upgrade failed', { status: 400 });
  }

  if (p === '/' || p === '/index.html') {
    return new Response(Bun.file('public/index.html'), { headers: { 'Content-Type': 'text/html' } });
  }

  if (p === '/api/status'        && method === 'GET')  return handleStatus();
  if (p === '/api/connect'       && method === 'POST') return handleConnect(req);
  if (p === '/api/disconnect'    && method === 'POST') return handleDisconnect();
  if (p === '/api/browse/remote' && method === 'GET')  return handleBrowseRemote(url);
  if (p === '/api/browse/local'  && method === 'GET')  return handleBrowseLocal(url);
  if (p === '/api/transfer'      && method === 'POST') return handleTransfer(req);
  if (p === '/api/upload'        && method === 'POST') return handleUpload(req);
  if (p === '/api/connections'   && method === 'GET')  return handleGetConnections();
  if (p === '/api/connections'   && method === 'POST') return handleSaveConnection(req);
  if (p === '/api/snippets'      && method === 'GET')  return handleGetSnippets();
  if (p === '/api/snippets'      && method === 'POST') return handleSaveSnippet(req);
  if (p === '/api/forwards'      && method === 'GET')  return handleListForwards();
  if (p === '/api/forwards'      && method === 'POST') return handleCreateForward(req);

  const cancelMatch = p.match(/^\/api\/transfer\/([^/]+)\/cancel$/);
  if (cancelMatch && method === 'POST') return handleCancel(cancelMatch[1]);

  const delConnMatch = p.match(/^\/api\/connections\/([^/]+)$/);
  if (delConnMatch && method === 'DELETE') return handleDeleteConnection(delConnMatch[1]);

  const delSnipMatch = p.match(/^\/api\/snippets\/([^/]+)$/);
  if (delSnipMatch && method === 'DELETE') return handleDeleteSnippet(delSnipMatch[1]);

  const delFwdMatch = p.match(/^\/api\/forwards\/([^/]+)$/);
  if (delFwdMatch && method === 'DELETE') return handleDeleteForward(delFwdMatch[1]);

  return new Response('Not found', { status: 404 });
}

// ─── Saved connections handlers ────────────────────────────────────

function handleGetConnections(): Response {
  return jsonResp({ connections: loadConnections() });
}

async function handleSaveConnection(req: Request): Promise<Response> {
  const body = await req.json() as Omit<SavedConnection, 'id'>;
  const conns = loadConnections();
  const idx = conns.findIndex(c => c.host === body.host && c.username === body.username && c.port === body.port);
  const conn: SavedConnection = { ...body, id: idx >= 0 ? conns[idx].id : randomUUID() };
  if (idx >= 0) conns[idx] = conn;
  else conns.push(conn);
  saveConnections(conns);
  return jsonResp({ connection: conn });
}

function handleDeleteConnection(id: string): Response {
  saveConnections(loadConnections().filter(c => c.id !== id));
  return jsonResp({ success: true });
}

// ─── SSH connection handlers ───────────────────────────────────────

function handleStatus(): Response {
  if (!connInfo) return jsonResp({ connected: false });
  return jsonResp({ connected: true, ...connInfo });
}

async function handleConnect(req: Request): Promise<Response> {
  const body = await req.json() as {
    host: string; port?: number; username: string;
    password?: string; privateKeyPath?: string;
    authMode: 'password' | 'key' | 'default';
  };

  if (sshClient) { sshClient.end(); sshClient = null; connInfo = null; }

  return new Promise(resolve => {
    const conn = new Client();
    const config: ConnectConfig = {
      host: body.host,
      port: body.port ?? 22,
      username: body.username,
      readyTimeout: 10000
    };

    if (body.authMode === 'password') {
      if (!body.password) return resolve(jsonResp({ error: 'Password required' }, 400));
      config.password = body.password;
    } else if (body.authMode === 'key') {
      const keyPath = body.privateKeyPath ?? join(homedir(), '.ssh', 'id_rsa');
      try { config.privateKey = readFileSync(keyPath); }
      catch { return resolve(jsonResp({ error: `Cannot read key: ${keyPath}` }, 400)); }
    } else {
      const candidates = ['.ssh/id_rsa', '.ssh/id_ed25519', '.ssh/id_ecdsa'].map(p => join(homedir(), p));
      for (const p of candidates) { try { config.privateKey = readFileSync(p); break; } catch {} }
      if (!config.privateKey) {
        return resolve(jsonResp({ error: 'No default SSH key found. Try Password or Key Path auth.' }, 400));
      }
    }

    conn.on('ready', () => {
      sshClient = conn;
      connInfo = { host: body.host, username: body.username, port: body.port ?? 22 };
      broadcast({ type: 'connected', host: body.host, username: body.username });
      resolve(jsonResp({ success: true }));
    });
    conn.on('error', err => resolve(jsonResp({ error: err.message }, 500)));
    conn.connect(config);
  });
}

function handleDisconnect(): Response {
  for (const [id, fwd] of forwardMap) { try { fwd.server.close(); } catch {} forwardMap.delete(id); }
  if (sshClient) { sshClient.end(); sshClient = null; connInfo = null; }
  broadcast({ type: 'disconnected' });
  return jsonResp({ success: true });
}

// ─── Terminal shell ────────────────────────────────────────────────
// Opens an interactive PTY via ssh2 shell() and wires it to a WebSocket.
function openTerminalShell(ws: import('bun').ServerWebSocket<any>) {
  if (!sshClient) { ws.close(1011, 'Not connected'); return; }
  sshClient.shell({ term: 'xterm-256color', cols: 220, rows: 50 }, (err, channel) => {
    if (err) { ws.close(1011, err.message); return; }
    ws.data.channel = channel;
    channel.on('data', (data: Buffer) => { try { ws.send(data); } catch {} });
    channel.stderr.on('data', (data: Buffer) => { try { ws.send(data); } catch {} });
    channel.on('close', () => { try { ws.close(); } catch {} });
  });
}

// ─── Snippet handlers ──────────────────────────────────────────────

function handleGetSnippets(): Response {
  return jsonResp({ snippets: loadSnippets() });
}

async function handleSaveSnippet(req: Request): Promise<Response> {
  const body = await req.json() as { label: string; command: string };
  const snippet: Snippet = { id: randomUUID(), label: body.label.trim(), command: body.command };
  saveSnippets([...loadSnippets(), snippet]);
  return jsonResp({ snippet });
}

function handleDeleteSnippet(id: string): Response {
  saveSnippets(loadSnippets().filter(s => s.id !== id));
  return jsonResp({ success: true });
}

// ─── Upload handler ────────────────────────────────────────────────

async function handleUpload(req: Request): Promise<Response> {
  if (!sshClient) return jsonResp({ error: 'Not connected' }, 400);
  const form = await req.formData();
  const file = form.get('file') as File;
  const remotePath = ((form.get('remotePath') as string) || '/tmp').replace(/\/$/, '') + '/' + file.name;
  const buf = Buffer.from(await file.arrayBuffer());
  return new Promise(resolve => {
    sshClient!.sftp((err, sftp) => {
      if (err) return resolve(jsonResp({ error: err.message }, 500));
      const ws = sftp.createWriteStream(remotePath);
      ws.on('close', () => { sftp.end(); resolve(jsonResp({ success: true, remotePath })); });
      ws.on('error', (e: Error) => { sftp.end(); resolve(jsonResp({ error: e.message }, 500)); });
      ws.end(buf);
    });
  });
}

// ─── Port forward handlers ─────────────────────────────────────────

async function handleCreateForward(req: Request): Promise<Response> {
  if (!sshClient) return jsonResp({ error: 'Not connected' }, 400);
  const { localPort, remoteHost, remotePort } = await req.json() as {
    localPort: number; remoteHost: string; remotePort: number;
  };
  return new Promise(resolve => {
    const id = randomUUID();
    const netServer = createNetServer(sock => {
      const fwd = forwardMap.get(id);
      if (fwd) fwd.connCount++;
      sshClient!.forwardOut('127.0.0.1', localPort, remoteHost, remotePort, (err, stream) => {
        if (err) { sock.destroy(); return; }
        sock.pipe(stream as any); (stream as any).pipe(sock);
        sock.on('close', () => { try { (stream as any).destroy(); } catch {} });
        (stream as any).on('close', () => { try { sock.destroy(); } catch {} });
      });
    });
    netServer.on('error', (err: Error) => resolve(jsonResp({ error: err.message }, 500)));
    netServer.listen(localPort, '127.0.0.1', () => {
      forwardMap.set(id, { id, localPort, remoteHost, remotePort, server: netServer, connCount: 0 });
      resolve(jsonResp({ success: true, forward: { id, localPort, remoteHost, remotePort, connCount: 0 } }));
    });
  });
}

function handleDeleteForward(id: string): Response {
  const fwd = forwardMap.get(id);
  if (fwd) { try { fwd.server.close(); } catch {} forwardMap.delete(id); }
  return jsonResp({ success: true });
}

function handleListForwards(): Response {
  const forwards = [...forwardMap.values()].map(({ id, localPort, remoteHost, remotePort, connCount }) =>
    ({ id, localPort, remoteHost, remotePort, connCount }));
  return jsonResp({ forwards });
}

// ─── File browser handlers ─────────────────────────────────────────

function handleBrowseRemote(url: URL): Promise<Response> {
  if (!sshClient) return Promise.resolve(jsonResp({ error: 'Not connected to server' }, 400));
  const remotePath = url.searchParams.get('path') || '/';

  return new Promise(resolve => {
    sshClient!.sftp((err, sftp) => {
      if (err) return resolve(jsonResp({ error: err.message }, 500));
      sftp.readdir(remotePath, (err, list) => {
        sftp.end();
        if (err) return resolve(jsonResp({ error: err.message }, 500));
        const files: FileEntry[] = list
          .filter(item => !item.filename.startsWith('.'))
          .map(item => ({
            name: item.filename,
            type: item.longname.startsWith('d') ? 'directory' : 'file',
            size: item.attrs.size ?? 0,
            modified: new Date((item.attrs.mtime ?? 0) * 1000).toISOString()
          }))
          .sort((a, b) => {
            if (a.type !== b.type) return a.type === 'directory' ? -1 : 1;
            return a.name.localeCompare(b.name);
          });
        resolve(jsonResp({ path: remotePath, parent: dirname(remotePath), files }));
      });
    });
  });
}

function handleBrowseLocal(url: URL): Response {
  const localPath = url.searchParams.get('path') || join(homedir(), 'Desktop');
  try {
    const entries = readdirSync(localPath, { withFileTypes: true });
    const files: FileEntry[] = entries
      .filter(e => !e.name.startsWith('.'))
      .map(e => {
        const full = join(localPath, e.name);
        let size = 0, modified = new Date().toISOString();
        try { const s = statSync(full); size = s.size; modified = s.mtime.toISOString(); } catch {}
        return { name: e.name, type: e.isDirectory() ? 'directory' : 'file', size, modified };
      })
      .sort((a, b) => {
        if (a.type !== b.type) return a.type === 'directory' ? -1 : 1;
        return a.name.localeCompare(b.name);
      });
    return jsonResp({ path: localPath, parent: dirname(localPath), files });
  } catch (err: any) {
    return jsonResp({ error: err.message }, 500);
  }
}

// ─── SSH remote execution helper ──────────────────────────────────
// sshClient.exec() runs commands on the remote server via SSH2 — not locally.
// Paths originate from SFTP directory listings, not from user text input.
function sshRemoteExec(cmd: string): Promise<string> {
  return new Promise((resolve, reject) => {
    if (!sshClient) return reject(new Error('Not connected'));
    sshClient.exec(cmd, (err, stream) => {
      if (err) return reject(err);
      let out = '';
      stream.on('data', (d: Buffer) => out += d.toString());
      stream.stderr.on('data', (d: Buffer) => console.error('[remote]', d.toString()));
      stream.on('close', (code: number) => {
        code === 0 ? resolve(out) : reject(new Error(`Remote command exited ${code}`));
      });
    });
  });
}

function checkRemoteIsDir(remotePath: string): Promise<boolean> {
  return sshRemoteExec(`test -d "${remotePath}" && echo yes || echo no`)
    .then(out => out.trim() === 'yes')
    .catch(() => false);
}

// ─── Transfer functions ────────────────────────────────────────────

// Bun.spawn with array args — no shell interpolation, safe
function rsyncTransfer(transferId: string, src: string, destDir: string): Promise<void> {
  return new Promise((resolve, reject) => {
    const args = ['-avz', '--progress', '-e', 'ssh -o StrictHostKeyChecking=no -o BatchMode=yes', src, destDir + '/'];
    const proc = spawn('rsync', args);
    transferMap.set(transferId, { status: 'running', process: proc });

    let buffer = '';
    proc.stdout.on('data', (chunk: Buffer) => {
      buffer += chunk.toString();
      const parts = buffer.split('\r'); buffer = parts.pop()!;
      for (const line of parts) {
        const p = parseRsyncProgress(line);
        if (p) broadcast({ type: 'progress', transferId, ...p, status: 'Downloading' });
      }
    });
    proc.stderr.on('data', (d: Buffer) => console.error('[rsync]', d.toString()));
    proc.on('close', code => {
      const state = transferMap.get(transferId); transferMap.delete(transferId);
      if (state?.status === 'cancelled') return resolve();
      if (code === 0 || code === 23) resolve();
      else reject(new Error(`rsync exited with code ${code}`));
    });
    proc.on('error', (err: NodeJS.ErrnoException) => {
      if (err.code === 'ENOENT') reject(Object.assign(new Error('rsync not found — install it with your package manager'), { isRsyncMissing: true }));
      else reject(err);
    });
  });
}

// SFTP single-file download — used when rsync is unavailable
function sftpDownloadFile(transferId: string, remotePath: string, localFilePath: string): Promise<void> {
  return new Promise((resolve, reject) => {
    if (!sshClient) return reject(new Error('Not connected'));
    sshClient.sftp((err, sftp) => {
      if (err) return reject(err);
      sftp.stat(remotePath, (statErr, stats) => {
        if (statErr) { sftp.end(); return reject(statErr); }
        const total = stats.size;
        let transferred = 0;
        const reader = sftp.createReadStream(remotePath);
        const writer = createWriteStream(localFilePath);
        reader.on('data', (chunk: Buffer) => {
          transferred += chunk.length;
          const percent = total ? Math.floor(transferred / total * 100) : 0;
          broadcast({ type: 'progress', transferId, percent, speed: '—', eta: '—', status: 'Downloading' });
        });
        reader.pipe(writer);
        writer.on('finish', () => { sftp.end(); resolve(); });
        reader.on('error', (e: Error) => { sftp.end(); writer.destroy(); reject(e); });
        writer.on('error', (e: Error) => { sftp.end(); reject(e); });
      });
    });
  });
}

// SFTP recursive directory download — used when rsync is unavailable
async function sftpDownloadDir(transferId: string, remotePath: string, localDest: string): Promise<void> {
  if (!sshClient) throw new Error('Not connected');
  const list = await new Promise<FileEntry[]>((resolve, reject) => {
    sshClient!.sftp((err, sftp) => {
      if (err) return reject(err);
      sftp.readdir(remotePath, (err, items) => {
        sftp.end();
        if (err) return reject(err);
        resolve(items
          .filter(i => i.filename !== '.' && i.filename !== '..')
          .map(i => ({
            name: i.filename,
            type: i.longname.startsWith('d') ? 'directory' : 'file',
            size: i.attrs.size ?? 0,
            modified: new Date((i.attrs.mtime ?? 0) * 1000).toISOString()
          })));
      });
    });
  });
  const localDir = join(localDest, basename(remotePath));
  mkdirSync(localDir, { recursive: true });
  for (const f of list) {
    const remoteChild = remotePath.replace(/\/$/, '') + '/' + f.name;
    if (f.type === 'directory') await sftpDownloadDir(transferId, remoteChild, localDir);
    else await sftpDownloadFile(transferId, remoteChild, join(localDir, f.name));
  }
}

async function compressAndTransfer(transferId: string, remotePath: string, localDest: string): Promise<void> {
  const { host, username } = connInfo!;
  const uid = randomUUID().slice(0, 8);
  const archiveName = `sbrdg_${uid}.tar.gz`;
  const remoteTmp = `/tmp/${archiveName}`;
  const localTmp = join(tmpdir(), archiveName);

  broadcast({ type: 'progress', transferId, percent: 0, speed: '—', eta: '—', status: 'Compressing on server...' });
  await sshRemoteExec(`tar -czf "${remoteTmp}" -C "${dirname(remotePath)}" "${basename(remotePath)}"`);

  let sizeLabel = '';
  try {
    const out = await sshRemoteExec(`stat -c%s "${remoteTmp}" 2>/dev/null || wc -c < "${remoteTmp}"`);
    const bytes = parseInt(out.trim());
    if (!isNaN(bytes)) sizeLabel = ` (${formatBytes(bytes)})`;
  } catch {}

  broadcast({ type: 'progress', transferId, percent: 5, speed: '—', eta: '—', status: `Downloading archive${sizeLabel}...` });

  // Transfer archive — try rsync, fall back to SFTP if not installed
  let rsyncFailed = false;
  try {
    await new Promise<void>((resolve, reject) => {
      const args = ['-az', '--progress', '-e', 'ssh -o StrictHostKeyChecking=no', `${username}@${host}:${remoteTmp}`, localTmp];
      const proc = spawn('rsync', args);
      transferMap.set(transferId, { status: 'running', process: proc });
      let buffer = '';
      proc.stdout.on('data', (chunk: Buffer) => {
        buffer += chunk.toString();
        const parts = buffer.split('\r'); buffer = parts.pop()!;
        for (const line of parts) {
          const p = parseRsyncProgress(line);
          if (p) {
            const pct = 5 + Math.floor(p.percent * 0.85);
            broadcast({ type: 'progress', transferId, percent: pct, speed: p.speed, eta: p.eta, status: 'Downloading...' });
          }
        }
      });
      proc.on('close', code => {
        const state = transferMap.get(transferId); transferMap.delete(transferId);
        if (state?.status === 'cancelled') return resolve();
        code === 0 ? resolve() : reject(new Error(`Archive transfer failed (code ${code})`));
      });
      proc.on('error', (err: NodeJS.ErrnoException) => {
        if (err.code === 'ENOENT') reject(Object.assign(err, { isRsyncMissing: true }));
        else reject(err);
      });
    });
  } catch (err: any) {
    if (!err.isRsyncMissing) throw err;
    rsyncFailed = true;
    broadcast({ type: 'progress', transferId, percent: 5, speed: '—', eta: '—', status: 'Downloading via SFTP...' });
    await sftpDownloadFile(transferId, remoteTmp, localTmp);
  }

  broadcast({ type: 'progress', transferId, percent: 92, speed: '—', eta: '—', status: 'Extracting...' });
  const result = Bun.spawnSync(['tar', '-xzf', localTmp, '-C', localDest]);
  if (result.exitCode !== 0) throw new Error(`Extraction failed: ${new TextDecoder().decode(result.stderr)}`);

  broadcast({ type: 'progress', transferId, percent: 98, speed: '—', eta: '—', status: 'Cleaning up...' });
  try { unlinkSync(localTmp); } catch {}
  sshRemoteExec(`rm -f "${remoteTmp}"`).catch(() => {});
}

// ─── Transfer handlers ─────────────────────────────────────────────

async function handleTransfer(req: Request): Promise<Response> {
  if (!sshClient || !connInfo) return jsonResp({ error: 'Not connected' }, 400);

  const { remotePath, compress = true, localDest } = await req.json() as {
    remotePath: string;
    compress: boolean;
    localDest: string;
  };

  const dest = localDest || join(homedir(), 'Desktop');
  const transferId = randomUUID();

  broadcast({ type: 'transfer_start', transferId, name: basename(remotePath), remotePath, localPath: dest });

  (async () => {
    try {
      const isDir = await checkRemoteIsDir(remotePath);
      if (compress && isDir) {
        await compressAndTransfer(transferId, remotePath, dest);
      } else {
        const src = `${connInfo!.username}@${connInfo!.host}:${remotePath}`;
        try {
          await rsyncTransfer(transferId, src, dest);
        } catch (err: any) {
          if (err.isRsyncMissing) {
            broadcast({ type: 'progress', transferId, percent: 0, speed: '—', eta: '—', status: 'Downloading via SFTP...' });
            if (isDir) await sftpDownloadDir(transferId, remotePath, dest);
            else await sftpDownloadFile(transferId, remotePath, join(dest, basename(remotePath)));
          } else throw err;
        }
      }
      broadcast({ type: 'transfer_complete', transferId });
    } catch (err: any) {
      broadcast({ type: 'transfer_error', transferId, error: err.message });
    }
  })();

  return jsonResp({ success: true, transferId });
}

function handleCancel(transferId: string): Response {
  const t = transferMap.get(transferId);
  if (t?.process) {
    t.process.kill('SIGTERM');
    transferMap.set(transferId, { status: 'cancelled' });
    broadcast({ type: 'transfer_cancelled', transferId });
  }
  return jsonResp({ success: true });
}

// ─── Server start ──────────────────────────────────────────────────

const PORT = 3847;

Bun.serve({
  port: PORT,
  fetch: handleRequest,
  websocket: {
    open(ws) {
      const d = ws.data as any;
      if (d?.type === 'terminal') {
        openTerminalShell(ws);
      } else {
        wsSet.add(ws);
        if (connInfo) ws.send(JSON.stringify({ type: 'connected', ...connInfo }));
      }
    },
    close(ws) {
      const d = ws.data as any;
      if (d?.type === 'terminal') {
        try { d.channel?.destroy(); } catch {}
      } else {
        wsSet.delete(ws);
      }
    },
    message(ws, msg) {
      const d = ws.data as any;
      if (d?.type === 'terminal' && d.channel) {
        if (typeof msg === 'string') {
          try {
            const parsed = JSON.parse(msg);
            if (parsed.type === 'resize') { d.channel.setWindow(parsed.rows, parsed.cols, 0, 0); return; }
          } catch {}
          d.channel.stdin.write(msg);
        } else {
          d.channel.stdin.write(Buffer.from(msg as ArrayBuffer));
        }
      }
    }
  }
});

console.log(`\n  ┌──────────────────────────────┐`);
console.log(`  │  SERVERBRDG                  │`);
console.log(`  │  http://localhost:${PORT}       │`);
console.log(`  └──────────────────────────────┘\n`);