@kirigami/php-prepros 1.0.9 → 1.1.0

package/src/prepros.js

@@ -1,9 +1,9 @@
 import fs from 'fs';
-import path, { dirname } from "path";
 import isBinary from './utils/isbinary.js';
 import joinWith from './utils/joinwith.js'
+import path, { dirname } from "path";
 import { spawn } from 'child_process';
-import { fileURLToPath } from 'url';
+import { fileURLToPath, pathToFileURL } from "url";
 import { walkFile } from '@kirigami/struct-walker';
 import { getPHPRuntime, getPHPRuntimeWithNetwork } from "@kirigami/php-wasm";
 
@@ -20,13 +20,14 @@ const config = await walkFile(__configpath);
 if(!config) throw `Invalid config file: ${__configpath}`;
 
 
+
 const getPHPInstance = async () => {
     if(!__php) {
         if(config?.kirigami?.root === undefined) throw `Missing prepros:root property in config file: ${__configpath}`;
         __root = path.join(__project, config.kirigami.root);
         if (!fs.existsSync(__root)) throw `Invalid prepros:root path: ${__root}`;
 
-        const preprosConfig = config.prepros;
+        const preprosConfig = config.prepros || {};
         preprosConfig.timezone = Intl.DateTimeFormat().resolvedOptions().timeZone;
         preprosConfig.root = joinWith('/project/', config?.kirigami?.root);
         preprosConfig.data = config.kirigami || {};
@@ -35,21 +36,49 @@ const getPHPInstance = async () => {
         __php.setSpawnHandler((command, args, options) => spawn(command, args, options));
         __php.preprosConfig = preprosConfig;
 
-        const mountPaths = [];
         const __cache = path.join(__project, '.cache.db');
+        const __cookie = path.join(__project, '.cookie.txt');
         mountPath(__php, __dirname, '/prepros');
         mountPath(__php, joinWith(__project, config?.kirigami?.root), joinWith('/project', config?.kirigami?.root));
+
         if (fs.existsSync(__cache)) mountPath(__php, __cache, '/project/.cache.db');
+        if (fs.existsSync(__cookie)) mountPath(__php, __cookie, '/project/.cookie.txt');
+
+        __php.onMessage(async (data) => {
+            const msg = JSON.parse(data);
+            if(!msg.command) return { success: false, error: "Invalid command."};
+            const file = path.join(__dirname, 'phpjs', `${msg.command}.js`);
+            if(!fs.existsSync(file)) return { success: false, error: "Invalid command."};
+
+            try {
+                const cmdModule = await import(pathToFileURL(file).href);
+                const results = await cmdModule.default(__php, msg);
+                return JSON.stringify({
+                    success: true,
+                    results: results
+                });
+            } catch(e) {
+                return {
+                    success: false,
+                    error: typeof e == 'string' ? e : e.message
+                }
+            }
+
+
+            // console.log(msg);
+            // console.log(__dirname);
+
+        });
     }
     return __php;
 }
 
 
 const mountPath = (php, localPath, virtualDir) => {
-    const includeExtensions = new Set(['.php', '.json', '.yaml', '.md', '.db', ...(config?.prepros?.mountext || [])]);
+    const includeExtensions = new Set(['.php', '.json', '.yaml', '.yml', '.md', '.db', '.txt', ...(config?.prepros?.mountext || [])]);
     const stat = fs.statSync(localPath);
     if (stat.isDirectory()) {
-        php.mkdir(virtualDir);
+        php.mkdirTree(virtualDir);
         for (const entry of fs.readdirSync(localPath, { withFileTypes: true })) {
             mountPath(php, path.join(localPath, entry.name), virtualDir + '/' + entry.name);
         }
@@ -57,46 +86,86 @@ const mountPath = (php, localPath, virtualDir) => {
         const ext = path.extname(localPath).toLowerCase();
         if (includeExtensions.has(ext)) {
             const buf = fs.readFileSync(localPath);
+            const parentDir = virtualDir.substring(0, virtualDir.lastIndexOf('/'));
+            if (parentDir) {
+                php.mkdirTree(parentDir);
+            }
             php.writeFile(virtualDir, isBinary(buf) ? buf : buf.toString('utf8'));
         }
     }
 }
 
 
-const run = async (args) => {
+const run = async (args = [], script = null, mountfiles = []) => {
     const php = await getPHPInstance();
+
+    await Promise.all(mountfiles.map(async item => {
+        const file = path.resolve(item);
+        if(!fs.existsSync(file)) return;
+        if(!path.relative(__project, file)) return;
+        const dest = path.join('/project', file.replace(__project, '')).replaceAll('\\', '/');
+        const buf = fs.readFileSync(file);
+        const parentDir = dest.substring(0, dest.lastIndexOf('/'));
+        if (parentDir) php.mkdirTree(parentDir);
+        php.writeFile(dest, isBinary(buf) ? buf : buf.toString('utf8'));
+    }));
+
     const output = await php.runStream({
-        scriptPath: '/prepros/prepros.php',
+        scriptPath: script || '/prepros/prepros.php',
         env: {
-            PREPROS_ARGS:   JSON.stringify(args),
+            PREPROS_ARGS: JSON.stringify(args),
             PREPROS_CONFIG: JSON.stringify(php.preprosConfig)
         }
     });
+
     const stdout = await output.stdoutText;
     const stderr = await output.stderrText;
+
     let retobj;
+    const resultPath = '/internal/prepros_result.json';
+
     try {
-        retobj = JSON.parse(stdout);
-		await Promise.all(retobj.files.map(async (file, i) => {
-			const buffer = php.readFileAsBuffer(file);
-			const dest = file.replace(/^\/project\//i, '');
-			fs.writeFileSync(path.join(__project, dest), buffer);
-			retobj.files[i] = dest;
-		}));
-    } catch(e) {
-        retobj = { success: false, error: 'Response parsing error.', response: stdout };
+        if (await php.fileExists(resultPath)) {
+            const buffer = php.readFileAsBuffer(resultPath);
+            retobj = JSON.parse(Buffer.from(buffer).toString('utf8'));
+            retobj.debug = stdout;
+
+            if(retobj.files) await Promise.all(retobj.files.map(async (file, i) => {
+                const fbuffer = php.readFileAsBuffer(file);
+                const dest = file.replace(/^\/project\//i, '');
+                const dir = dirname(path.join(__project, dest));
+                if(!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+                fs.writeFileSync(path.join(__project, dest), fbuffer);
+                retobj.files[i] = dest;
+            }));
+        } else {
+            retobj = { success: true, files: [], debug: stdout };
+        }
+    } catch (e) {
+        retobj = { success: false, error: 'Response parsing error.' + e, debug: stdout, stderr };
+    } finally {
+        if (await php.fileExists(resultPath)) {
+            await php.unlink(resultPath);
+        }
     }
     if (stderr) {
-        try {
-            retobj = JSON.parse(stderr);
-        } catch(e) { 
-            retobj = { success: false, error: stderr };
-        }
+        retobj = { success: false, error: stderr, debug: stdout };
     }
+
     return retobj;
 }
 
 
+const runenv = async (script, paths = [], ...args) => {
+    if(!script) throw "Missing PHP file.";
+    const file = path.resolve(script);
+    if(!path.relative(__project, file)) throw "PHP file outside project";
+    if(!fs.existsSync(file)) throw "Can't find PHP file";
+    const dest = path.join('/project', file.replace(__project, '')).replaceAll('\\', '/');
+    return run([dest, ...args], '/prepros/runenv.php', [file, ...paths]);
+}
+
+
 const render = async (file = '.') => {
     const php = await getPHPInstance();
     const target = path.resolve(__project, config?.kirigami?.root, file);
@@ -123,4 +192,4 @@ const sitemap = async (dir) => {
 }
 
 
-export { render, sitemap };
+export { runenv, render, sitemap };

package/src/prepros.php

@@ -1,23 +1,10 @@
 <?php
 
-ini_set('log_errors', 1);
-ini_set('html_errors', 0);
-ini_set('display_errors', 1);
-ini_set('error_reporting', 32767);
-ini_set('error_log', 'php://stderr');
-error_reporting(E_ALL);
-
-
-$argv = array_merge(['prepros.php'], json_decode(getenv('PREPROS_ARGS'), true));
-$config = json_decode(getenv('PREPROS_CONFIG'));
-
+include(__DIR__ . '/utils.inc.php');
 
 try {
-
-    date_default_timezone_set($config->timezone);
     if (!isset($argv[1])) STD::error("Invalid argument.");
-    include(__DIR__ . '/utils.inc.php');
-    PREPROS::loadConfig($config);
+    
     if($argv[1] == 'sitemap') {
         if(!PREPROS::sitemap()) STD::error("Can't produce the sitemap.");
         STD::succeed(['files' => PREPROS::getExportedFiles()]);
@@ -38,8 +25,8 @@ try {
     }
 
 } catch(Exception $e) {
-    STD::error($e->getMessage());
+    STD::error(['message' => $e->getMessage()]);
 }
 
 
-STD::succeed(['files' => PREPROS::getExportedFiles()]);
+STD::succeed();

package/src/runenv.php

@@ -0,0 +1,17 @@
+<?php
+
+include(__DIR__ . '/utils.inc.php');
+
+
+try {
+
+    if (!isset($argv[1])) STD::error("Invalid PHP file.");
+    if (!is_file($argv[1])) STD::error("PHP file not found.");
+
+    require_once($argv[1]);
+
+} catch(Exception $e) {
+    STD::error($e->getMessage());
+}
+
+STD::succeed(['files' => PREPROS::getExportedFiles()]);

package/src/utils/findfile.js

@@ -0,0 +1,25 @@
+import fs from 'fs';
+import path from "path";
+import picomatch from "picomatch";
+
+export default function findFiles(pattern, cwd = process.cwd()) {
+	const isMatch = picomatch(pattern);
+	const results = [];
+	function walk(dir) {
+		const entries = fs.readdirSync(dir, { withFileTypes: true });
+		for (const entry of entries) {
+			const fullPath = path.join(dir, entry.name);
+			const relativePath = path.relative(cwd, fullPath);
+			if (entry.isDirectory()) {
+				if (entry.name === 'node_modules' || entry.name === '.git') continue;
+				walk(fullPath);
+			} else if (entry.isFile()) {
+				if (isMatch(relativePath.split(path.sep).join('/'))) {
+					results.push(relativePath.replaceAll('\\', '/'));
+				}
+			}
+		}
+	}
+	walk(cwd);
+	return results;
+}

package/src/utils.inc.php

@@ -1,4 +1,11 @@
 <?php
+ini_set('log_errors', 1);
+ini_set('html_errors', 0);
+ini_set('display_errors', 1);
+ini_set('error_reporting', 32767);
+ini_set('error_log', 'php://stderr');
+error_reporting(E_ALL);
+
 
 const BR = '<br>';
 const RN = "\r\n";
@@ -14,16 +21,28 @@ function _print_r(mixed $obj) {
 
 spl_autoload_register(function ($class) {
     static $catalog = [
+        'ARR'             => 'arr.class.php',    
         'CACHE'           => 'cache.class.php',
+        'CURL'            => 'curl.class.php',
 		'FS'              => 'fs.class.php',
         'HTML'            => 'html.class.php',
         'IMG'             => 'img.class.php',
         'MD'              => 'md.class.php',
         'OBF'             => 'obf.class.php',
 		'PREPROS'         => 'prepros.class.php',
-		'STD'             => 'std.class.php',
+		'SCRAPER'         => 'scraper.class.php',
+        'STD'             => 'std.class.php',
         'STR'             => 'str.class.php',
         'YAML'            => 'yaml.class.php',
     ];
     if (isset($catalog[$class])) require_once(__DIR__ . '/libraries/' . $catalog[$class]);
-}, true, true);
+}, true, true);
+
+
+$argv = array_merge(['prepros.php'], json_decode(getenv('PREPROS_ARGS'), true));
+$config = json_decode(getenv('PREPROS_CONFIG'));
+date_default_timezone_set($config->timezone);
+chdir('/project');
+
+
+PREPROS::loadConfig($config);