@salism3/dsh-latex-editor 0.0.0-stage → 1.0.0

package/index.js

@@ -0,0 +1,994 @@
+import { spawn } from 'node:child_process';
+import { createHash } from 'node:crypto';
+import { existsSync, statSync, readFileSync, writeFileSync, createReadStream, mkdirSync, readdirSync, rmSync } from 'node:fs';
+import { createServer as createHttpServer, request as httpRequest } from 'node:http';
+import { connect as netConnect } from 'node:net';
+import { networkInterfaces, tmpdir } from 'node:os';
+import { resolve, join, dirname } from 'node:path';
+
+export const name = 'dsh-latex-editor';
+export const inject = ['webServer', 'systemPrompt', 'tools', 'workingDirectory', 'workspaceRegistry'];
+
+const MIKTEX_BIN_DIR = process.env.LATEX_BIN_DIR || process.env.MIKTEX_BIN_DIR || 'D:\\miktex\\miktex\\bin\\x64';
+
+let isCompiling = false;
+let lastLog = '';
+let lastSuccess = false;
+let lastCompileTime = 0;
+
+function resolveWorkspace(ctx) {
+  // 1. Cek workspaceRegistry
+  try {
+    if (ctx.workspaceRegistry && typeof ctx.workspaceRegistry.list === 'function') {
+      const list = ctx.workspaceRegistry.list();
+      if (list && list.length > 0) {
+        for (const w of list) {
+          if (w.path && existsSync(join(w.path, 'main.tex'))) {
+            return w.path;
+          }
+        }
+        if (list[0]?.path && existsSync(list[0].path)) {
+          return list[0].path;
+        }
+      }
+    }
+  } catch {}
+
+  // 2. Cek workingDirectory default
+  try {
+    if (ctx.workingDirectory && typeof ctx.workingDirectory.defaultDirectory === 'string') {
+      const dir = ctx.workingDirectory.defaultDirectory;
+      if (existsSync(join(dir, 'main.tex'))) {
+        return dir;
+      }
+    }
+  } catch {}
+
+  // 3. Cek process.cwd()
+  const cwd = process.cwd();
+  if (existsSync(join(cwd, 'main.tex'))) {
+    return cwd;
+  }
+
+  // 4. Cek fallback default-workspace lokal
+  const localDefault = join(cwd, 'default-workspace');
+  if (existsSync(localDefault)) {
+    return localDefault;
+  }
+
+  return cwd;
+}
+
+// Workspace aktif: klien mengirim path workspace sesi yang sedang dibuka.
+// Hanya path yang terdaftar sebagai workspace DSH yang diterima.
+function normalizePathForMatch(value) {
+  return String(value)
+    .trim()
+    .replace(/\//g, '\\')
+    .replace(/\\{2,}/g, '\\')
+    .replace(/\\+$/u, '')
+    .toLowerCase();
+}
+
+function pickWorkspace(ctx, requested) {
+  const fallback = resolveWorkspace(ctx);
+  if (typeof requested !== 'string' || requested.trim() === '') return fallback;
+
+  try {
+    const registry = ctx.workspaceRegistry;
+    const list = registry && typeof registry.list === 'function' ? registry.list() : [];
+    const target = normalizePathForMatch(requested);
+    const match = list.find((item) => item && typeof item.path === 'string' && normalizePathForMatch(item.path) === target);
+    if (match && existsSync(match.path)) return match.path;
+  } catch {}
+
+  return fallback;
+}
+
+function readRequestedWorkspace(req, body) {
+  if (body && typeof body.ws === 'string') return body.ws;
+  try {
+    const url = new URL(req.url || '/', 'http://localhost');
+    const value = url.searchParams.get('ws');
+    if (value) return value;
+  } catch {}
+  return undefined;
+}
+
+function resolveBinary(engine = 'xelatex') {
+  const binaryName = engine === 'pdflatex' ? 'pdflatex.exe' : 'xelatex.exe';
+  const customPath = join(MIKTEX_BIN_DIR, binaryName);
+  if (existsSync(customPath)) {
+    return customPath;
+  }
+  return binaryName;
+}
+
+function resolveTool(binaryName) {
+  const customPath = join(MIKTEX_BIN_DIR, binaryName);
+  return existsSync(customPath) ? customPath : binaryName;
+}
+
+function miktexEnv() {
+  return { ...process.env, PATH: `${MIKTEX_BIN_DIR};${process.env.PATH || ''}` };
+}
+
+// ===========================================================================
+// Cache raster halaman PDF (dipakai viewer internal, bukan plugin PDF browser)
+// ===========================================================================
+const PAGE_DPI = 150;
+
+const pdfMetaCache = new Map();
+const pageRenderJobs = new Map();
+
+function pageCacheRoot(workspaceDir) {
+  const hash = createHash('sha1').update(String(workspaceDir).toLowerCase()).digest('hex').slice(0, 16);
+  return join(tmpdir(), 'dsh-latex-pages', hash);
+}
+
+function prunePageCache(workspaceDir, keepDirName) {
+  try {
+    const root = pageCacheRoot(workspaceDir);
+    if (!existsSync(root)) return;
+    for (const name of readdirSync(root)) {
+      if (name === keepDirName) continue;
+      try {
+        rmSync(join(root, name), { recursive: true, force: true });
+      } catch {}
+    }
+  } catch {}
+}
+
+function runPdfInfo(pdfPath, workspaceDir) {
+  return new Promise((resolvePromise) => {
+    let stdout = '';
+    let proc;
+    try {
+      proc = spawn(resolveTool('pdfinfo.exe'), [pdfPath], {
+        cwd: workspaceDir,
+        env: miktexEnv(),
+        windowsHide: true,
+      });
+    } catch {
+      resolvePromise(null);
+      return;
+    }
+    proc.stdout.on('data', (d) => {
+      stdout += d.toString();
+    });
+    proc.on('error', () => resolvePromise(null));
+    proc.on('close', () => {
+      const pages = /^Pages:\s+(\d+)/m.exec(stdout);
+      const size = /^Page size:\s+([\d.]+)\s+x\s+([\d.]+)\s+pts/m.exec(stdout);
+      if (!pages) {
+        resolvePromise(null);
+        return;
+      }
+      resolvePromise({
+        pageCount: Number(pages[1]),
+        widthPt: size ? Number(size[1]) : 595.28,
+        heightPt: size ? Number(size[2]) : 841.89,
+      });
+    });
+  });
+}
+
+async function readPdfMeta(workspaceDir) {
+  const pdfPath = join(workspaceDir, 'main.pdf');
+  if (!existsSync(pdfPath)) return null;
+  const st = statSync(pdfPath);
+  const cacheKey = `${pdfPath}@${st.mtimeMs}`;
+  const cached = pdfMetaCache.get(cacheKey);
+  if (cached) return { ...cached, pdfMtime: st.mtimeMs };
+  const meta = await runPdfInfo(pdfPath, workspaceDir);
+  if (!meta) return null;
+  pdfMetaCache.set(cacheKey, meta);
+  for (const key of pdfMetaCache.keys()) {
+    if (key !== cacheKey && key.startsWith(`${pdfPath}@`)) pdfMetaCache.delete(key);
+  }
+  return { ...meta, pdfMtime: st.mtimeMs };
+}
+
+function renderPagePng(workspaceDir, page) {
+  return new Promise((resolvePromise) => {
+    const pdfPath = join(workspaceDir, 'main.pdf');
+    if (!existsSync(pdfPath)) {
+      resolvePromise(null);
+      return;
+    }
+
+    const mtime = statSync(pdfPath).mtimeMs;
+    const dirName = String(Math.round(mtime));
+    const dir = join(pageCacheRoot(workspaceDir), dirName);
+    const output = join(dir, `p${page}.png`);
+
+    if (existsSync(output)) {
+      resolvePromise(output);
+      return;
+    }
+
+    if (pageRenderJobs.has(output)) {
+      resolvePromise(pageRenderJobs.get(output));
+      return;
+    }
+
+    const job = new Promise((done) => {
+      try {
+        mkdirSync(dir, { recursive: true });
+      } catch {
+        done(null);
+        return;
+      }
+
+      let proc;
+      try {
+        proc = spawn(
+          resolveTool('pdftoppm.exe'),
+          ['-f', String(page), '-l', String(page), '-r', String(PAGE_DPI), '-png', '-singlefile', pdfPath, join(dir, `p${page}`)],
+          { cwd: workspaceDir, env: miktexEnv(), windowsHide: true }
+        );
+      } catch {
+        done(null);
+        return;
+      }
+
+      proc.on('error', () => done(null));
+      proc.on('close', (code) => {
+        prunePageCache(workspaceDir, dirName);
+        done(code === 0 && existsSync(output) ? output : null);
+      });
+    }).finally(() => {
+      pageRenderJobs.delete(output);
+    });
+
+    pageRenderJobs.set(output, job);
+    resolvePromise(job);
+  });
+}
+
+
+function runCompile(workspaceDir, engine = 'xelatex') {
+  return new Promise((resolvePromise) => {
+    const mainTexPath = join(workspaceDir, 'main.tex');
+    if (!existsSync(mainTexPath)) {
+      resolvePromise({
+        ok: false,
+        log: 'Error: main.tex tidak ditemukan di root workspace. Buat dokumen main.tex terlebih dahulu.',
+        pdfExists: false,
+        durationMs: 0,
+      });
+      return;
+    }
+
+    isCompiling = true;
+    const startTime = Date.now();
+    const bin = resolveBinary(engine);
+    const args = ['-interaction=nonstopmode', '-halt-on-error', 'main.tex'];
+
+    const env = {
+      ...process.env,
+      PATH: `${MIKTEX_BIN_DIR};${process.env.PATH || ''}`,
+    };
+
+    let stdout = '';
+    let stderr = '';
+
+    const proc = spawn(bin, args, {
+      cwd: workspaceDir,
+      env,
+      windowsHide: true,
+    });
+
+    proc.stdout.on('data', (d) => {
+      stdout += d.toString();
+    });
+
+    proc.stderr.on('data', (d) => {
+      stderr += d.toString();
+    });
+
+    proc.on('error', (err) => {
+      isCompiling = false;
+      const durationMs = Date.now() - startTime;
+      const combinedLog = `Gagal menjalankan binary ${bin}: ${err.message}\n\nSTDOUT:\n${stdout}\nSTDERR:\n${stderr}`;
+      lastLog = combinedLog;
+      lastSuccess = false;
+      lastCompileTime = Date.now();
+      resolvePromise({
+        ok: false,
+        log: combinedLog,
+        pdfExists: existsSync(join(workspaceDir, 'main.pdf')),
+        durationMs,
+      });
+    });
+
+    proc.on('close', (code) => {
+      isCompiling = false;
+      const durationMs = Date.now() - startTime;
+      const pdfPath = join(workspaceDir, 'main.pdf');
+      const pdfExists = existsSync(pdfPath);
+      const combinedLog = `${stdout}\n${stderr}`.trim();
+      const ok = code === 0 && pdfExists;
+
+      lastLog = combinedLog;
+      lastSuccess = ok;
+      lastCompileTime = Date.now();
+
+      resolvePromise({
+        ok,
+        code,
+        log: combinedLog,
+        pdfExists,
+        durationMs,
+        pdfMtime: pdfExists ? statSync(pdfPath).mtimeMs : 0,
+      });
+    });
+  });
+}
+
+function readJsonBody(req) {
+  return new Promise((resolvePromise) => {
+    let body = '';
+    req.on('data', (chunk) => {
+      body += chunk;
+      if (body.length > 1024 * 1024) {
+        req.destroy();
+      }
+    });
+    req.on('end', () => {
+      try {
+        resolvePromise(body ? JSON.parse(body) : {});
+      } catch {
+        resolvePromise({});
+      }
+    });
+  });
+}
+
+function safeRegisterRoute(webServer, route) {
+  try {
+    const table = route.kind === 'exact' ? webServer.exact : webServer.prefixes;
+    if (table && typeof table.delete === 'function' && table.has(route.path)) {
+      table.delete(route.path);
+    }
+  } catch {}
+  return webServer.register(route);
+}
+
+// ===========================================================================
+// Gateway remote: bind 0.0.0.0 (wildcard) lalu proxy ke web server lokal.
+// Web server DSH sendiri menolak bind wildcard, jadi plugin ini menyediakan
+// pintu masuk tanpa autentikasi untuk jaringan lokal.
+// ===========================================================================
+const REMOTE_GATEWAY_PORT = Number.parseInt(process.env.DSH_LATEX_REMOTE_PORT || '60856', 10);
+
+const HOP_BY_HOP_HEADERS = new Set([
+  'connection',
+  'keep-alive',
+  'proxy-authenticate',
+  'proxy-authorization',
+  'te',
+  'trailer',
+  'transfer-encoding',
+  'upgrade',
+  'host',
+  'cookie',
+]);
+
+function listLanAddresses() {
+  const addresses = [];
+  try {
+    const interfaces = networkInterfaces();
+    for (const entries of Object.values(interfaces)) {
+      for (const entry of entries || []) {
+        if (!entry || entry.internal) continue;
+        if (entry.family !== 'IPv4' && entry.family !== 4) continue;
+        addresses.push(entry.address);
+      }
+    }
+  } catch {}
+  return addresses;
+}
+
+async function resolveAuthCookie(ctx, localOrigin) {
+  try {
+    const connection = ctx.get('connection');
+    if (!connection || typeof connection.authenticatedUrl !== 'function') return null;
+    const url = connection.authenticatedUrl(localOrigin);
+    const response = await fetch(url, { redirect: 'manual' });
+    const raw =
+      typeof response.headers.getSetCookie === 'function'
+        ? response.headers.getSetCookie()
+        : [response.headers.get('set-cookie')].filter(Boolean);
+    for (const line of raw) {
+      const pair = String(line).split(';')[0];
+      if (pair && pair.includes('=')) return pair.trim();
+    }
+  } catch {}
+  return null;
+}
+
+function startRemoteGateway(ctx) {
+  const origin = ctx.webServer.getOrigin();
+  const target = new URL(origin);
+  const targetHost = target.hostname;
+  const targetPort = Number(target.port || (target.protocol === 'https:' ? 443 : 80));
+  const localAuthority = target.host;
+
+  let cookiePromise = null;
+  const authCookie = () => {
+    if (cookiePromise === null) cookiePromise = resolveAuthCookie(ctx, origin);
+    return cookiePromise;
+  };
+
+  const proxyHeaders = (headers, cookie) => {
+    const out = {};
+    for (const [name, value] of Object.entries(headers)) {
+      const key = name.toLowerCase();
+      if (HOP_BY_HOP_HEADERS.has(key)) continue;
+      out[key] = value;
+    }
+    out.host = localAuthority;
+    if (out.origin !== undefined) out.origin = origin;
+    if (out.referer !== undefined) out.referer = `${origin}/`;
+    if (cookie) out.cookie = cookie;
+    return out;
+  };
+
+  const server = createHttpServer((req, res) => {
+    authCookie()
+      .then((cookie) => {
+        const outgoing = httpRequest(
+          {
+            host: targetHost,
+            port: targetPort,
+            method: req.method,
+            path: req.url,
+            headers: proxyHeaders(req.headers, cookie),
+          },
+          (upstreamResponse) => {
+            res.writeHead(upstreamResponse.statusCode || 502, upstreamResponse.headers);
+            upstreamResponse.pipe(res);
+          }
+        );
+        outgoing.on('error', () => {
+          try {
+            res.writeHead(502, { 'Content-Type': 'text/plain; charset=utf-8' });
+            res.end('latex-editor: gateway remote gagal menghubungi server lokal');
+          } catch {}
+        });
+        req.pipe(outgoing);
+      })
+      .catch(() => {
+        try {
+          res.writeHead(500);
+          res.end();
+        } catch {}
+      });
+  });
+
+  server.on('upgrade', (req, socket, head) => {
+    authCookie()
+      .then((cookie) => {
+        const headers = proxyHeaders(req.headers, cookie);
+        headers.connection = 'Upgrade';
+        headers.upgrade = req.headers.upgrade || 'websocket';
+
+        let raw = `${req.method} ${req.url} HTTP/1.1\r\n`;
+        for (const [name, value] of Object.entries(headers)) {
+          raw += `${name}: ${Array.isArray(value) ? value.join(', ') : value}\r\n`;
+        }
+        raw += '\r\n';
+
+        const upstream = netConnect(targetPort, targetHost, () => {
+          upstream.write(raw);
+          if (head && head.length > 0) upstream.write(head);
+          upstream.pipe(socket);
+          socket.pipe(upstream);
+        });
+        upstream.on('error', () => socket.destroy());
+        socket.on('error', () => upstream.destroy());
+        socket.on('close', () => upstream.destroy());
+      })
+      .catch(() => socket.destroy());
+  });
+
+  server.on('error', (error) => {
+    console.warn(`latex-editor: gateway remote tidak dapat bind port ${REMOTE_GATEWAY_PORT}: ${error.message}`);
+  });
+
+  server.listen(REMOTE_GATEWAY_PORT, '0.0.0.0', () => {
+    const urls = listLanAddresses().map((address) => `http://${address}:${REMOTE_GATEWAY_PORT}`);
+    console.log(`latex-editor: gateway remote aktif (tanpa auth) di 0.0.0.0:${REMOTE_GATEWAY_PORT}`);
+    for (const url of urls) console.log(`latex-editor: remote URL ${url}`);
+  });
+
+  return () => {
+    try {
+      server.close();
+    } catch {}
+  };
+}
+
+// ===========================================================================
+// Perbaikan: versi plugin sebelumnya membungkus workspaceRegistry.create
+// (mode satu proyek). Bungkus itu hidup di instance service dan tidak ikut
+// hilang saat plugin di-reload, jadi dilepas di sini agar pembuatan workspace
+// kembali memakai implementasi asli.
+// ===========================================================================
+function repairWorkspaceRegistry(ctx) {
+  try {
+    const registry = ctx.workspaceRegistry;
+    if (!registry) return;
+    if (registry.__latexSingleWorkspace === true) {
+      try {
+        delete registry.create;
+      } catch {}
+      try {
+        delete registry.__latexSingleWorkspace;
+      } catch {}
+    }
+  } catch {}
+}
+
+// ===========================================================================
+// Pembuatan workspace langsung (tanpa dialog): folder dibuat otomatis di
+// samping workspace default, lalu didaftarkan ke workspaceRegistry.
+// ===========================================================================
+async function createAutoWorkspace(ctx, options = {}) {
+  const registry = ctx.workspaceRegistry;
+  if (!registry || typeof registry.create !== 'function') {
+    throw new Error('Layanan workspace tidak tersedia.');
+  }
+  repairWorkspaceRegistry(ctx);
+
+  const list = typeof registry.list === 'function' ? registry.list() : [];
+  const base = list.find((item) => item && typeof item.path === 'string' && item.path)?.path || resolveWorkspace(ctx);
+  const parent = dirname(base);
+  const taken = new Set(list.filter((item) => item && item.path).map((item) => item.path.toLowerCase()));
+
+  let index = 1;
+  let title = '';
+  let target = '';
+  for (;;) {
+    title = `proyek-${index}`;
+    target = join(parent, title);
+
+    if (taken.has(target.toLowerCase())) {
+      index += 1;
+      continue;
+    }
+
+    if (!existsSync(target)) break;
+
+    // Folder sisa percobaan sebelumnya boleh dipakai ulang selama masih kosong.
+    let reusable = false;
+    try {
+      reusable = readdirSync(target).length === 0;
+    } catch {}
+    if (reusable) break;
+
+    index += 1;
+    if (index > 500) throw new Error('Tidak dapat menentukan nama folder proyek baru.');
+  }
+
+  if (options.dryRun === true) {
+    return { id: null, path: target, title, dryRun: true };
+  }
+
+  mkdirSync(target, { recursive: true });
+  const workspace = await registry.create(target, title);
+  return {
+    id: workspace?.id ?? null,
+    path: workspace?.path ?? target,
+    title: workspace?.title ?? title,
+  };
+}
+
+export function apply(ctx) {
+  repairWorkspaceRegistry(ctx);
+  // 1. INJEKSI SOUL / SYSTEM PROMPT (Wajib generate main.tex sebagai entry point)
+  // =========================================================================
+  if (ctx.systemPrompt && typeof ctx.systemPrompt.section === 'function') {
+    ctx.effect(() =>
+      ctx.systemPrompt.section({
+        name: 'latex-editor-core-mandate',
+        order: 5,
+        text: `
+# PERAN & INSTRUKSI UTAMA: AI LATEX EDITOR (DEEPSEEK HARNESS)
+
+Anda beroperasi sebagai asisten khusus LaTeX Editor interaktif dengan live compiler & PDF viewer.
+
+## ATURAN MUTLAK ENTRY POINT: main.tex
+1. Dokumen utama atau entry point proyek LaTeX HARUS SELALU bernama 'main.tex'.
+2. Setiap kali membuat dokumen baru, mengedit artikel, laporan, tugas, CV, paper ilmiah, atau presentasi Beamer, Anda WAJIB membuat atau memperbarui file 'main.tex' di root direktori workspace.
+3. 'main.tex' harus lengkap, valid, dan self-contained (memiliki \\documentclass, package-package yang diperlukan, \\begin{document}, dan \\end{document}).
+4. Jika proyek memerlukan pemisahan bab atau sub-berkas (misal: chapters/bab1.tex), pastikan berkas induk 'main.tex' memuat berkas-berkas tersebut menggunakan \\input{...} atau \\include{...}.
+5. Gunakan paket-paket standar yang kompatibel dengan XeLaTeX dan pdfLaTeX (misalnya: amsmath, amssymb, graphicx, hyperref, geometry, booktabs, xcolor). Hindari sintaksis usang atau paket non-standar yang memerlukan interaksi manual.
+6. Tampilan pratinjau PDF dan tombol 'Compile LaTeX' berada tepat di sebelah kanan layar chat ini. Setelah Anda selesai menulis atau memperbarui 'main.tex', beri tahu pengguna bahwa dokumen siap dikompilasi atau dapat dilihat langsung pada panel PDF sebelah kanan.
+        `.trim(),
+      })
+    );
+  }
+
+  // =========================================================================
+  // 2. REGISTRASI AGENT TOOL: latex_compile
+  // =========================================================================
+  if (ctx.tools && typeof ctx.tools.register === 'function') {
+    ctx.effect(() => {
+      try {
+        return ctx.tools.register({
+          name: 'latex_compile',
+          description: 'Mengompilasi berkas main.tex di workspace menjadi main.pdf menggunakan engine XeLaTeX atau pdfLaTeX.',
+          parameters: {
+            type: 'object',
+            properties: {
+              engine: {
+                type: 'string',
+                enum: ['xelatex', 'pdflatex'],
+                description: 'Engine LaTeX yang digunakan untuk kompilasi. Default: xelatex.',
+              },
+            },
+          },
+          output: {
+            schema: {
+              type: 'object',
+              properties: {
+                ok: { type: 'boolean' },
+                durationMs: { type: 'number' },
+                logSnippet: { type: 'string' },
+              },
+              required: ['ok'],
+            },
+            render(args, val) {
+              const v = val || {};
+              if (v.ok) {
+                return [{ type: 'text', text: `LaTeX compilation succeeded! main.pdf diperbarui dalam ${v.durationMs || 0}ms.` }];
+              }
+              return [{ type: 'text', text: `Kompilasi LaTeX gagal:\n${v.logSnippet || 'Tidak ada detail log'}` }];
+            },
+          },
+          async execute(args) {
+            const workspaceDir = resolveWorkspace(ctx);
+            const engine = args?.engine || 'xelatex';
+            const res = await runCompile(workspaceDir, engine);
+            const logSnippet = (res.log || '').split('\n').slice(-25).join('\n');
+            return {
+              ok: res.ok,
+              durationMs: res.durationMs,
+              logSnippet,
+            };
+          },
+        });
+      } catch {
+        return () => {};
+      }
+    });
+  }
+
+  // =========================================================================
+  // 3. HTTP ENDPOINTS PADA ctx.webServer
+  // =========================================================================
+  if (ctx.webServer && typeof ctx.webServer.register === 'function') {
+    // 3.1. POST /api/latex/compile
+    ctx.effect(() =>
+      safeRegisterRoute(ctx.webServer, {
+        kind: 'exact',
+        path: '/api/latex/compile',
+        handler: async (req, res) => {
+          res.setHeader('Access-Control-Allow-Origin', '*');
+          res.setHeader('Access-Control-Allow-Methods', 'GET, POST, OPTIONS');
+          res.setHeader('Access-Control-Allow-Headers', '*');
+
+          if (req.method === 'OPTIONS') {
+            res.writeHead(204);
+            res.end();
+            return;
+          }
+
+          const body = await readJsonBody(req);
+          const engine = body.engine || 'xelatex';
+          const requestedWs = readRequestedWorkspace(req, body);
+          const selectedDir = pickWorkspace(ctx, requestedWs);
+
+          const result = await runCompile(selectedDir, engine);
+
+          res.writeHead(200, { 'Content-Type': 'application/json' });
+          res.end(JSON.stringify({ ...result, workspace: selectedDir }));
+        },
+      })
+    );
+
+    // 3.2. GET /api/latex/pdf
+    ctx.effect(() =>
+      safeRegisterRoute(ctx.webServer, {
+        kind: 'exact',
+        path: '/api/latex/pdf',
+        handler: async (req, res) => {
+          res.setHeader('Access-Control-Allow-Origin', '*');
+          res.setHeader('Access-Control-Allow-Methods', 'GET, OPTIONS');
+
+          if (req.method === 'OPTIONS') {
+            res.writeHead(204);
+            res.end();
+            return;
+          }
+
+          const workspaceDir = pickWorkspace(ctx, readRequestedWorkspace(req));
+          const pdfPath = join(workspaceDir, 'main.pdf');
+
+          if (!existsSync(pdfPath)) {
+            res.writeHead(404, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ error: 'main.pdf belum tersedia. Silakan kompilasi main.tex terlebih dahulu.' }));
+            return;
+          }
+
+          try {
+            const stat = statSync(pdfPath);
+            res.writeHead(200, {
+              'Content-Type': 'application/pdf',
+              'Content-Length': stat.size,
+              'Content-Disposition': 'inline; filename="main.pdf"',
+              'Cache-Control': 'no-cache, no-store, must-revalidate',
+            });
+            createReadStream(pdfPath).pipe(res);
+          } catch (err) {
+            res.writeHead(500, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ error: err.message }));
+          }
+        },
+      })
+    );
+
+    // 3.3. GET /api/latex/status
+    ctx.effect(() =>
+      safeRegisterRoute(ctx.webServer, {
+        kind: 'exact',
+        path: '/api/latex/status',
+        handler: async (req, res) => {
+          res.setHeader('Access-Control-Allow-Origin', '*');
+          res.setHeader('Access-Control-Allow-Methods', 'GET, OPTIONS');
+
+          if (req.method === 'OPTIONS') {
+            res.writeHead(204);
+            res.end();
+            return;
+          }
+
+          const workspaceDir = pickWorkspace(ctx, readRequestedWorkspace(req));
+          const texPath = join(workspaceDir, 'main.tex');
+          const pdfPath = join(workspaceDir, 'main.pdf');
+
+          const mainTexExists = existsSync(texPath);
+          const mainPdfExists = existsSync(pdfPath);
+
+          const texMtime = mainTexExists ? statSync(texPath).mtimeMs : 0;
+          const pdfMtime = mainPdfExists ? statSync(pdfPath).mtimeMs : 0;
+
+          let pageCount = 0;
+          let widthPt = 595.28;
+          let heightPt = 841.89;
+          if (mainPdfExists) {
+            const meta = await readPdfMeta(workspaceDir);
+            if (meta) {
+              pageCount = meta.pageCount;
+              widthPt = meta.widthPt;
+              heightPt = meta.heightPt;
+            }
+          }
+
+          res.writeHead(200, { 'Content-Type': 'application/json' });
+          res.end(
+            JSON.stringify({
+              ok: true,
+              workspace: workspaceDir,
+              mainTexExists,
+              mainPdfExists,
+              texMtime,
+              pdfMtime,
+              pageCount,
+              widthPt,
+              heightPt,
+              needsCompile: mainTexExists && texMtime > pdfMtime,
+              isCompiling,
+              lastLog,
+              lastSuccess,
+              lastCompileTime,
+            })
+          );
+        },
+      })
+    );
+
+    // 3.4. GET /api/latex/pages - Metadata halaman PDF untuk viewer internal
+    ctx.effect(() =>
+      safeRegisterRoute(ctx.webServer, {
+        kind: 'exact',
+        path: '/api/latex/pages',
+        handler: async (req, res) => {
+          res.setHeader('Access-Control-Allow-Origin', '*');
+          res.setHeader('Access-Control-Allow-Methods', 'GET, OPTIONS');
+
+          if (req.method === 'OPTIONS') {
+            res.writeHead(204);
+            res.end();
+            return;
+          }
+
+          const workspaceDir = pickWorkspace(ctx, readRequestedWorkspace(req));
+          const meta = await readPdfMeta(workspaceDir);
+
+          res.writeHead(200, {
+            'Content-Type': 'application/json',
+            'Cache-Control': 'no-store',
+          });
+          res.end(
+            JSON.stringify({
+              ok: Boolean(meta),
+              pageCount: meta ? meta.pageCount : 0,
+              widthPt: meta ? meta.widthPt : 595.28,
+              heightPt: meta ? meta.heightPt : 841.89,
+              pdfMtime: meta ? meta.pdfMtime : 0,
+            })
+          );
+        },
+      })
+    );
+
+    // 3.5. GET /api/latex/page?n=<nomor> - Raster PNG satu halaman
+    ctx.effect(() =>
+      safeRegisterRoute(ctx.webServer, {
+        kind: 'exact',
+        path: '/api/latex/page',
+        handler: async (req, res) => {
+          res.setHeader('Access-Control-Allow-Origin', '*');
+          res.setHeader('Access-Control-Allow-Methods', 'GET, OPTIONS');
+
+          if (req.method === 'OPTIONS') {
+            res.writeHead(204);
+            res.end();
+            return;
+          }
+
+          const workspaceDir = pickWorkspace(ctx, readRequestedWorkspace(req));
+          let page = 1;
+          try {
+            const url = new URL(req.url || '/', 'http://localhost');
+            page = Number.parseInt(url.searchParams.get('n') || '1', 10);
+          } catch {}
+          if (!Number.isFinite(page) || page < 1 || page > 5000) {
+            res.writeHead(400, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ error: 'Nomor halaman tidak valid.' }));
+            return;
+          }
+
+          const pngPath = await renderPagePng(workspaceDir, page);
+          if (!pngPath || !existsSync(pngPath)) {
+            res.writeHead(404, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ error: `Halaman ${page} belum tersedia.` }));
+            return;
+          }
+
+          try {
+            const stat = statSync(pngPath);
+            res.writeHead(200, {
+              'Content-Type': 'image/png',
+              'Content-Length': stat.size,
+              'Cache-Control': 'private, max-age=31536000, immutable',
+            });
+            createReadStream(pngPath).pipe(res);
+          } catch (err) {
+            res.writeHead(500, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ error: err.message }));
+          }
+        },
+      })
+    );
+
+    // 3.6. POST /api/latex/init
+    ctx.effect(() =>
+      safeRegisterRoute(ctx.webServer, {
+        kind: 'exact',
+        path: '/api/latex/init',
+        handler: async (req, res) => {
+          res.setHeader('Access-Control-Allow-Origin', '*');
+          res.setHeader('Access-Control-Allow-Methods', 'POST, OPTIONS');
+
+          if (req.method === 'OPTIONS') {
+            res.writeHead(204);
+            res.end();
+            return;
+          }
+
+          const workspaceDir = pickWorkspace(ctx, readRequestedWorkspace(req));
+          const texPath = join(workspaceDir, 'main.tex');
+
+          if (!existsSync(texPath)) {
+            const starterTemplate = `\\documentclass[11pt,a4paper]{article}
+\\usepackage[utf8]{inputenc}
+\\usepackage{amsmath,amssymb}
+\\usepackage{graphicx}
+\\usepackage{hyperref}
+\\usepackage{geometry}
+\\geometry{a4paper, margin=1in}
+
+\\title{\\textbf{Dokumen LaTeX AI}}
+\\author{Dibuat dengan DeepSeek Harness}
+\\date{\\today}
+
+\\begin{document}
+
+\\maketitle
+
+\\begin{abstract}
+Dokumen ini dibuat otomatis oleh DeepSeek Harness LaTeX Editor AI. Anda dapat langsung mengedit berkas \\texttt{main.tex} ini atau meminta AI di kolom chat untuk menulis artikel, rumus matematika, atau laporan lengkap.
+\\end{abstract}
+
+\\section{Pendahuluan}
+Selamat datang di \\textbf{LaTeX AI Studio}! Dokumen ini adalah berkas \\texttt{main.tex} yang berfungsi sebagai entry point utama.
+
+\\section{Contoh Persamaan Matematika}
+Berikut adalah contoh persamaan kuadrat dan integral kalkulus:
+\\begin{equation}
+E = mc^2
+\\end{equation}
+
+\\begin{equation}
+\\int_{0}^{\\infty} e^{-x^2} dx = \\frac{\\sqrt{\\pi}}{2}
+\\end{equation}
+
+\\section{Kesimpulan}
+Kompilasi berkas ini dengan menekan tombol \\textbf{Compile} di panel pratinjau sebelah kanan.
+
+\\end{document}
+`;
+            writeFileSync(texPath, starterTemplate, 'utf8');
+          }
+
+          res.writeHead(200, { 'Content-Type': 'application/json' });
+          res.end(JSON.stringify({ ok: true, created: true }));
+        },
+      })
+    );
+
+    // 3.7. POST /api/latex/workspace/new - Buat workspace + folder langsung
+    ctx.effect(() =>
+      safeRegisterRoute(ctx.webServer, {
+        kind: 'exact',
+        path: '/api/latex/workspace/new',
+        handler: async (req, res) => {
+          res.setHeader('Access-Control-Allow-Origin', '*');
+          res.setHeader('Access-Control-Allow-Methods', 'GET, POST, OPTIONS');
+          res.setHeader('Access-Control-Allow-Headers', '*');
+
+          if (req.method === 'OPTIONS') {
+            res.writeHead(204);
+            res.end();
+            return;
+          }
+
+          try {
+            let dryRun = false;
+            try {
+              const url = new URL(req.url || '/', 'http://localhost');
+              dryRun = url.searchParams.get('dry') === '1';
+            } catch {}
+            const workspace = await createAutoWorkspace(ctx, { dryRun });
+            res.writeHead(200, { 'Content-Type': 'application/json', 'Cache-Control': 'no-store' });
+            res.end(JSON.stringify({ ok: true, ...workspace }));
+          } catch (error) {
+            res.writeHead(500, { 'Content-Type': 'application/json', 'Cache-Control': 'no-store' });
+            res.end(JSON.stringify({ ok: false, error: error instanceof Error ? error.message : String(error) }));
+          }
+        },
+      })
+    );
+  }
+
+  // =========================================================================
+  // 5. GATEWAY REMOTE WILDCARD (0.0.0.0) TANPA AUTH
+  // =========================================================================
+  if (ctx.webServer && typeof ctx.webServer.getOrigin === 'function') {
+    ctx.effect(() => startRemoteGateway(ctx));
+  }
+}