cwresdev 0.1.0

package/src/server.js

@@ -0,0 +1,334 @@
+const fs = require("node:fs");
+const http = require("node:http");
+const path = require("node:path");
+
+const chokidar = require("chokidar");
+const express = require("express");
+const { WebSocketServer } = require("ws");
+
+const { CLIENT_SCRIPT_ROUTE, getClientScriptSource, injectLiveReload } = require("./injector");
+const { startPhpServer, stopPhpServer } = require("./php");
+const { buildTargetUrl, proxyRequest } = require("./proxy");
+
+const HTML_EXTENSIONS = new Set([".htm", ".html", ".shtm", ".shtml"]);
+const MAX_SSI_INCLUDE_DEPTH = 16;
+const SSI_INCLUDE_PATTERN = /<!--#include\s+(virtual|file)\s*=\s*"([^"]+)"\s*-->/gi;
+
+function createLogger(quiet) {
+  if (quiet) {
+    return {
+      error() {},
+      info() {},
+      warn() {},
+    };
+  }
+
+  return console;
+}
+
+function safeResolve(docRoot, requestPath) {
+  const docRootResolved = path.resolve(docRoot);
+  const trimmedPath = requestPath === "/" ? "" : requestPath.replace(/^\/+/, "");
+  const candidate = path.resolve(docRootResolved, trimmedPath);
+
+  if (candidate !== docRootResolved && !candidate.startsWith(`${docRootResolved}${path.sep}`)) {
+    throw new Error(`Refusing to serve a path outside the doc root: ${requestPath}`);
+  }
+
+  return candidate;
+}
+
+async function pathExists(candidate) {
+  try {
+    await fs.promises.access(candidate, fs.constants.F_OK);
+    return true;
+  } catch (error) {
+    return false;
+  }
+}
+
+function isHtmlFilePath(filePath) {
+  return HTML_EXTENSIONS.has(path.extname(filePath).toLowerCase());
+}
+
+function assertWithinDocRoot(docRoot, candidatePath, sourceLabel) {
+  const docRootResolved = path.resolve(docRoot);
+  const candidateResolved = path.resolve(candidatePath);
+
+  if (candidateResolved !== docRootResolved && !candidateResolved.startsWith(`${docRootResolved}${path.sep}`)) {
+    throw new Error(`SSI include resolves outside the doc root: ${sourceLabel}`);
+  }
+
+  return candidateResolved;
+}
+
+function resolveSsiIncludePath(docRoot, currentFilePath, includeType, includePath) {
+  const trimmedPath = typeof includePath === "string" ? includePath.trim() : "";
+
+  if (!trimmedPath) {
+    throw new Error("SSI include path must be a non-empty string.");
+  }
+
+  if (includeType === "file" && path.isAbsolute(trimmedPath)) {
+    throw new Error(`SSI file include must be relative: ${trimmedPath}`);
+  }
+
+  if (includeType === "virtual" && trimmedPath.startsWith("/")) {
+    return safeResolve(docRoot, trimmedPath);
+  }
+
+  const candidate = path.resolve(path.dirname(currentFilePath), trimmedPath);
+  return assertWithinDocRoot(docRoot, candidate, trimmedPath);
+}
+
+async function renderHtmlWithSsi(docRoot, filePath, state = {}) {
+  const depth = state.depth ?? 0;
+  const seenFiles = state.seenFiles ?? new Set();
+  const resolvedFilePath = assertWithinDocRoot(docRoot, filePath, filePath);
+
+  if (depth > MAX_SSI_INCLUDE_DEPTH) {
+    throw new Error(`SSI include depth exceeded while resolving ${resolvedFilePath}`);
+  }
+
+  if (seenFiles.has(resolvedFilePath)) {
+    throw new Error(`SSI circular include detected for ${resolvedFilePath}`);
+  }
+
+  const fileContents = await fs.promises.readFile(resolvedFilePath, "utf8");
+  const matches = Array.from(fileContents.matchAll(SSI_INCLUDE_PATTERN));
+
+  if (matches.length === 0) {
+    return fileContents;
+  }
+
+  const nextSeenFiles = new Set(seenFiles);
+  nextSeenFiles.add(resolvedFilePath);
+
+  let renderedHtml = "";
+  let lastIndex = 0;
+
+  for (const match of matches) {
+    const [directive, includeType, includePath] = match;
+    const directiveIndex = match.index ?? 0;
+    const includeFilePath = resolveSsiIncludePath(docRoot, resolvedFilePath, includeType, includePath);
+    const includeStats = await fs.promises.stat(includeFilePath).catch(() => null);
+
+    if (!includeStats || !includeStats.isFile()) {
+      throw new Error(`SSI include not found: ${includePath}`);
+    }
+
+    renderedHtml += fileContents.slice(lastIndex, directiveIndex);
+    renderedHtml += await renderHtmlWithSsi(docRoot, includeFilePath, {
+      depth: depth + 1,
+      seenFiles: nextSeenFiles,
+    });
+    lastIndex = directiveIndex + directive.length;
+  }
+
+  renderedHtml += fileContents.slice(lastIndex);
+  return renderedHtml;
+}
+
+async function resolveRequestTarget(docRoot, requestPath) {
+  const decodedPath = decodeURIComponent(requestPath);
+  const candidate = safeResolve(docRoot, decodedPath);
+
+  if (await pathExists(candidate)) {
+    const stats = await fs.promises.stat(candidate);
+
+    if (stats.isFile()) {
+      if (candidate.toLowerCase().endsWith(".php")) {
+        return { found: true, type: "php", filePath: candidate };
+      }
+
+      if (isHtmlFilePath(candidate)) {
+        return { found: true, type: "html", filePath: candidate };
+      }
+
+      return { found: true, type: "asset", filePath: candidate };
+    }
+
+    if (stats.isDirectory()) {
+      if (!requestPath.endsWith("/")) {
+        return { found: true, type: "directory", redirectTo: requestPath + "/" };
+      }
+
+      const indexPhp = path.join(candidate, "index.php");
+      const indexHtml = path.join(candidate, "index.html");
+      const indexHtm = path.join(candidate, "index.htm");
+      const indexShtml = path.join(candidate, "index.shtml");
+      const indexShtm = path.join(candidate, "index.shtm");
+
+      if (await pathExists(indexPhp)) {
+        return { found: true, type: "php", filePath: indexPhp };
+      }
+
+      if (await pathExists(indexHtml)) {
+        return { found: true, type: "html", filePath: indexHtml };
+      }
+
+      if (await pathExists(indexHtm)) {
+        return { found: true, type: "html", filePath: indexHtm };
+      }
+
+      if (await pathExists(indexShtml)) {
+        return { found: true, type: "html", filePath: indexShtml };
+      }
+
+      if (await pathExists(indexShtm)) {
+        return { found: true, type: "html", filePath: indexShtm };
+      }
+    }
+  }
+
+  return { found: false };
+}
+
+function broadcastReload(clients) {
+  for (const client of clients) {
+    if (client.readyState === client.OPEN) {
+      client.send("reload");
+    }
+  }
+}
+
+async function startDevServer(config) {
+  if (!fs.existsSync(config.docRoot)) {
+    throw new Error(`Doc root does not exist: ${config.docRoot}`);
+  }
+
+  const logger = createLogger(config.quiet);
+  const packageRoot = path.resolve(__dirname, "..");
+  const phpServer = await startPhpServer({
+    packageRoot,
+    docRoot: config.docRoot,
+    host: config.host,
+    logger,
+    phpBinary: config.phpBinary,
+  });
+
+  const app = express();
+  const httpServer = http.createServer(app);
+  const wss = new WebSocketServer({ noServer: true });
+  const wsClients = new Set();
+  const clientScript = getClientScriptSource();
+
+  app.disable("x-powered-by");
+
+  httpServer.on("upgrade", (req, socket, head) => {
+    if (req.url !== "/__cwrespro/ws") {
+      socket.destroy();
+      return;
+    }
+
+    wss.handleUpgrade(req, socket, head, (ws) => {
+      wsClients.add(ws);
+      ws.on("close", () => wsClients.delete(ws));
+    });
+  });
+
+  app.get(CLIENT_SCRIPT_ROUTE, (req, res) => {
+    res.type("application/javascript");
+    res.send(clientScript);
+  });
+
+  app.use("/objects", async (req, res, next) => {
+    try {
+      await proxyRequest({
+        req,
+        res,
+        target: buildTargetUrl(config.proxyOrigin, req),
+      });
+    } catch (error) {
+      next(error);
+    }
+  });
+
+  app.use(async (req, res, next) => {
+    try {
+      const target = await resolveRequestTarget(config.docRoot, req.path);
+
+      if (!target.found) {
+        res.status(404).type("text/plain").send(`Not found: ${req.path}`);
+        return;
+      }
+
+      if (target.type === "directory") {
+        const query = req.originalUrl.includes("?") ? req.originalUrl.slice(req.originalUrl.indexOf("?")) : "";
+        res.redirect(301, target.redirectTo + query);
+        return;
+      }
+
+      if (target.type === "php") {
+        await proxyRequest({
+          req,
+          res,
+          target: buildTargetUrl(phpServer.baseUrl, req),
+          injectHtml: true,
+        });
+        return;
+      }
+
+      if (target.type === "html") {
+        const html = await renderHtmlWithSsi(config.docRoot, target.filePath);
+        res.type("html");
+        res.send(injectLiveReload(html));
+        return;
+      }
+
+      res.sendFile(target.filePath);
+    } catch (error) {
+      next(error);
+    }
+  });
+
+  app.use((error, req, res, next) => {
+    logger.error(`[cwrespro] ${error.stack || error.message}`);
+    if (res.headersSent) {
+      next(error);
+      return;
+    }
+
+    res.status(500).type("text/plain").send(error.message);
+  });
+
+  let reloadTimer = null;
+  const watcher = chokidar.watch(config.docRoot, {
+    ignoreInitial: true,
+    ignored: config.watchIgnored,
+  });
+
+  watcher.on("all", (eventName, filePath) => {
+    clearTimeout(reloadTimer);
+    reloadTimer = setTimeout(() => {
+      broadcastReload(wsClients);
+    }, 75);
+  });
+
+  await new Promise((resolve, reject) => {
+    httpServer.once("error", reject);
+    httpServer.listen(config.port, config.host, resolve);
+  });
+
+  const address = httpServer.address();
+  const url = `http://${config.host}:${address.port}/`;
+
+  async function close() {
+    clearTimeout(reloadTimer);
+    await watcher.close();
+    await new Promise((resolve) => httpServer.close(resolve));
+    wss.close();
+    await stopPhpServer(phpServer);
+  }
+
+  return {
+    close,
+    phpServer,
+    port: address.port,
+    url,
+  };
+}
+
+module.exports = {
+  startDevServer,
+};

package/vendor/php/windows/README.md

@@ -0,0 +1,140 @@
+<div align="center">
+    <a href="https://www.php.net">
+        <img
+            alt="PHP"
+            src="https://www.php.net/images/logos/new-php-logo.svg"
+            width="150">
+    </a>
+</div>
+
+# The PHP Interpreter
+
+PHP is a popular general-purpose scripting language that is especially suited to
+web development. Fast, flexible and pragmatic, PHP powers everything from your
+blog to the most popular websites in the world. PHP is distributed under the
+[PHP License v3.01](LICENSE).
+
+[![Push](https://github.com/php/php-src/actions/workflows/push.yml/badge.svg)](https://github.com/php/php-src/actions/workflows/push.yml)
+[![Fuzzing Status](https://oss-fuzz-build-logs.storage.googleapis.com/badges/php.svg)](https://bugs.chromium.org/p/oss-fuzz/issues/list?sort=-opened&can=1&q=proj:php)
+
+## Documentation
+
+The PHP manual is available at [php.net/docs](https://www.php.net/docs).
+
+## Installation
+
+### Prebuilt packages and binaries
+
+Prebuilt packages and binaries can be used to get up and running fast with PHP.
+
+For Windows, the PHP binaries can be obtained from
+[windows.php.net](https://windows.php.net). After extracting the archive the
+`*.exe` files are ready to use.
+
+For other systems, see the [installation chapter](https://www.php.net/install).
+
+### Building PHP source code
+
+*For Windows, see [Build your own PHP on Windows](https://wiki.php.net/internals/windows/stepbystepbuild_sdk_2).*
+
+For a minimal PHP build from Git, you will need autoconf, bison, and re2c. For
+a default build, you will additionally need libxml2 and libsqlite3.
+
+On Ubuntu, you can install these using:
+
+    sudo apt install -y pkg-config build-essential autoconf bison re2c \
+                        libxml2-dev libsqlite3-dev
+
+On Fedora, you can install these using:
+
+    sudo dnf install re2c bison autoconf make libtool ccache libxml2-devel sqlite-devel
+
+Generate configure:
+
+    ./buildconf
+
+Configure your build. `--enable-debug` is recommended for development, see
+`./configure --help` for a full list of options.
+
+    # For development
+    ./configure --enable-debug
+    # For production
+    ./configure
+
+Build PHP. To speed up the build, specify the maximum number of jobs using `-j`:
+
+    make -j4
+
+The number of jobs should usually match the number of available cores, which
+can be determined using `nproc`.
+
+## Testing PHP source code
+
+PHP ships with an extensive test suite, the command `make test` is used after
+successful compilation of the sources to run this test suite.
+
+It is possible to run tests using multiple cores by setting `-jN` in
+`TEST_PHP_ARGS`:
+
+    make TEST_PHP_ARGS=-j4 test
+
+Shall run `make test` with a maximum of 4 concurrent jobs: Generally the maximum
+number of jobs should not exceed the number of cores available.
+
+The [qa.php.net](https://qa.php.net) site provides more detailed info about
+testing and quality assurance.
+
+## Installing PHP built from source
+
+After a successful build (and test), PHP may be installed with:
+
+    make install
+
+Depending on your permissions and prefix, `make install` may need super user
+permissions.
+
+## PHP extensions
+
+Extensions provide additional functionality on top of PHP. PHP consists of many
+essential bundled extensions. Additional extensions can be found in the PHP
+Extension Community Library - [PECL](https://pecl.php.net).
+
+## Contributing
+
+The PHP source code is located in the Git repository at
+[github.com/php/php-src](https://github.com/php/php-src). Contributions are most
+welcome by forking the repository and sending a pull request.
+
+Discussions are done on GitHub, but depending on the topic can also be relayed
+to the official PHP developer mailing list internals@lists.php.net.
+
+New features require an RFC and must be accepted by the developers. See
+[Request for comments - RFC](https://wiki.php.net/rfc) and
+[Voting on PHP features](https://wiki.php.net/rfc/voting) for more information
+on the process.
+
+Bug fixes don't require an RFC. If the bug has a GitHub issue, reference it in
+the commit message using `GH-NNNNNN`. Use `#NNNNNN` for tickets in the old
+[bugs.php.net](https://bugs.php.net) bug tracker.
+
+    Fix GH-7815: php_uname doesn't recognise latest Windows versions
+    Fix #55371: get_magic_quotes_gpc() throws deprecation warning
+
+See [Git workflow](https://wiki.php.net/vcs/gitworkflow) for details on how pull
+requests are merged.
+
+### Guidelines for contributors
+
+See further documents in the repository for more information on how to
+contribute:
+
+- [Contributing to PHP](/CONTRIBUTING.md)
+- [PHP coding standards](/CODING_STANDARDS.md)
+- [Internal documentation](https://php.github.io/php-src/)
+- [Mailing list rules](/docs/mailinglist-rules.md)
+- [PHP release process](/docs/release-process.md)
+
+## Credits
+
+For the list of people who've put work into PHP, please see the
+[PHP credits page](https://www.php.net/credits.php).