zerg-ztc 0.1.0 → 0.1.2

package/src/web/mirror_server.ts

@@ -0,0 +1,204 @@
+import { createServer, IncomingMessage, ServerResponse } from 'http';
+import { readFile, mkdir, writeFile } from 'fs/promises';
+import { resolve, join, basename } from 'path';
+import { homedir } from 'os';
+import { randomUUID } from 'crypto';
+import { InputBus, InputEvent } from '../ui/core/input.js';
+import { LayoutNode, computeLayout, LayoutFrame } from '../ui/core/index.js';
+
+interface Client {
+  id: string;
+  res: ServerResponse;
+  cols: number;
+  rows: number;
+}
+
+export class MirrorServer {
+  private clients = new Map<string, Client>();
+  private port: number;
+  private server = createServer(this.handleRequest.bind(this));
+  private lastTree: LayoutNode | null = null;
+  private inputBus?: InputBus;
+
+  constructor(port: number, inputBus?: InputBus) {
+    this.port = port;
+    this.inputBus = inputBus;
+  }
+
+  start(): void {
+    this.server.listen(this.port);
+  }
+
+  stop(): void {
+    this.server.close();
+  }
+
+  publish(tree: LayoutNode): void {
+    this.lastTree = tree;
+    for (const client of this.clients.values()) {
+      this.sendLayout(client, tree);
+    }
+  }
+
+  private async handleRequest(req: IncomingMessage, res: ServerResponse): Promise<void> {
+    const url = new URL(req.url || '/', `http://${req.headers.host || 'localhost'}`);
+
+    if (url.pathname === '/') {
+      const htmlPath = new URL('./mirror.html', import.meta.url);
+      const html = await readFile(htmlPath, 'utf-8').catch(async () => {
+        const fallback = resolve(process.cwd(), 'src/web/mirror.html');
+        return readFile(fallback, 'utf-8');
+      });
+      res.writeHead(200, { 'Content-Type': 'text/html' });
+      res.end(html);
+      return;
+    }
+
+    if (url.pathname === '/mirror-favicon.svg' || url.pathname === '/favicon.svg' || url.pathname === '/favicon.ico') {
+      const iconPath = new URL('./mirror-favicon.svg', import.meta.url);
+      const icon = await readFile(iconPath, 'utf-8').catch(async () => {
+        const fallback = resolve(process.cwd(), 'src/web/mirror-favicon.svg');
+        return readFile(fallback, 'utf-8');
+      });
+      const contentType = url.pathname === '/favicon.ico' ? 'image/x-icon' : 'image/svg+xml';
+      res.writeHead(200, { 'Content-Type': contentType, 'Cache-Control': 'no-cache' });
+      res.end(icon);
+      return;
+    }
+
+    if (url.pathname === '/events') {
+      const id = url.searchParams.get('id') || `client_${Date.now()}`;
+      res.writeHead(200, {
+        'Content-Type': 'text/event-stream',
+        'Cache-Control': 'no-cache',
+        Connection: 'keep-alive'
+      });
+      res.write('\n');
+
+      const client: Client = {
+        id,
+        res,
+        cols: 80,
+        rows: 24
+      };
+      this.clients.set(id, client);
+
+      if (this.lastTree) {
+        this.sendLayout(client, this.lastTree);
+      }
+
+      req.on('close', () => {
+        this.clients.delete(id);
+      });
+      return;
+    }
+
+    if (url.pathname === '/size' && req.method === 'POST') {
+      const id = url.searchParams.get('id');
+      if (!id || !this.clients.has(id)) {
+        res.writeHead(400);
+        res.end();
+        return;
+      }
+
+      const body = await new Promise<string>(resolve => {
+        let data = '';
+        req.on('data', chunk => { data += chunk; });
+        req.on('end', () => resolve(data));
+      });
+
+      try {
+        const parsed = JSON.parse(body) as { cols: number; rows: number };
+        const client = this.clients.get(id);
+        if (client) {
+          client.cols = parsed.cols;
+          client.rows = parsed.rows;
+          if (this.lastTree) {
+            this.sendLayout(client, this.lastTree);
+          }
+        }
+      } catch {
+        // Ignore invalid payloads
+      }
+
+      res.writeHead(204);
+      res.end();
+      return;
+    }
+
+    if (url.pathname === '/input' && req.method === 'POST') {
+      const body = await new Promise<string>(resolve => {
+        let data = '';
+        req.on('data', chunk => { data += chunk; });
+        req.on('end', () => resolve(data));
+      });
+
+      try {
+        const parsed = JSON.parse(body) as InputEvent;
+        this.inputBus?.emit(parsed);
+      } catch {
+        // Ignore invalid payloads
+      }
+
+      res.writeHead(204);
+      res.end();
+      return;
+    }
+
+    if (url.pathname === '/upload' && req.method === 'POST') {
+      const buffer = await new Promise<Buffer>(resolve => {
+        const chunks: Buffer[] = [];
+        req.on('data', chunk => { chunks.push(Buffer.from(chunk)); });
+        req.on('end', () => resolve(Buffer.concat(chunks)));
+      });
+      const headerName = req.headers['x-filename'];
+      const rawName = typeof headerName === 'string' && headerName.trim().length > 0 ? headerName : 'upload.bin';
+      const safeName = basename(rawName).replace(/[^a-zA-Z0-9._-]/g, '_');
+      const dir = join(homedir(), '.ztc', 'uploads');
+      await mkdir(dir, { recursive: true });
+      const filePath = join(dir, `${Date.now()}-${randomUUID().slice(0, 8)}-${safeName}`);
+      await writeFile(filePath, buffer);
+      res.writeHead(200, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ path: filePath }));
+      return;
+    }
+
+    if (url.pathname === '/file' && req.method === 'GET') {
+      const rawPath = url.searchParams.get('path');
+      if (!rawPath) {
+        res.writeHead(400);
+        res.end();
+        return;
+      }
+      const allowedRoots = [
+        join(homedir(), '.ztc', 'uploads'),
+        join(homedir(), '.ztc', 'clipboard')
+      ];
+      const resolvedPath = resolve(rawPath);
+      const allowed = allowedRoots.some(root => resolvedPath.startsWith(resolve(root)));
+      if (!allowed) {
+        res.writeHead(403);
+        res.end();
+        return;
+      }
+      try {
+        const data = await readFile(resolvedPath);
+        res.writeHead(200, { 'Content-Type': 'application/octet-stream' });
+        res.end(data);
+      } catch {
+        res.writeHead(404);
+        res.end();
+      }
+      return;
+    }
+
+    res.writeHead(404);
+    res.end();
+  }
+
+  private sendLayout(client: Client, tree: LayoutNode): void {
+    const frame = computeLayout(tree, client.cols, client.rows);
+    const payload = JSON.stringify(frame);
+    client.res.write(`data: ${payload}\n\n`);
+  }
+}