create-prisma-php-app 3.5.4 → 3.6.1

package/dist/settings/restart-websocket.ts

@@ -1,53 +1,52 @@
-import { spawn, ChildProcess } from "child_process";
 import { join } from "path";
-import chokidar from "chokidar";
-import { getFileMeta } from "./utils.js";
-
-const { __dirname } = getFileMeta();
-
-const phpPath = "php";
+import {
+  createRestartableProcess,
+  createSrcWatcher,
+  DebouncedWorker,
+  DEFAULT_AWF,
+  onExit,
+} from "./utils.js";
+
+// Config
+const phpPath = process.env.PHP_PATH ?? "php";
+const SRC_DIR = join(process.cwd(), "src");
 const serverScriptPath = join(
-  __dirname,
-  "..",
-  "src",
+  SRC_DIR,
   "Lib",
   "Websocket",
   "websocket-server.php"
 );
 
-let serverProcess: ChildProcess | null = null;
-
-const restartServer = (): void => {
-  if (serverProcess) {
-    console.log("Stopping WebSocket server...");
-    serverProcess.kill("SIGINT");
-    serverProcess = null;
-  }
-
-  console.log("Starting WebSocket server...");
-  serverProcess = spawn(phpPath, [serverScriptPath]);
-
-  serverProcess.stdout?.on("data", (data: Buffer) => {
-    console.log(`WebSocket Server: ${data.toString()}`);
-  });
-
-  serverProcess.stderr?.on("data", (data: Buffer) => {
-    console.error(`WebSocket Server Error: ${data.toString()}`);
-  });
-
-  serverProcess.on("close", (code: number) => {
-    console.log(`WebSocket server exited with code ${code}`);
-  });
-};
-
-// Initial start
-restartServer();
+// Restartable WS server
+const ws = createRestartableProcess({
+  name: "WebSocket",
+  cmd: phpPath,
+  args: [serverScriptPath],
+  windowsKillTree: true,
+});
+
+ws.start();
+
+// Debounced restarter
+const restarter = new DebouncedWorker(
+  async () => {
+    await ws.restart("file change");
+  },
+  400,
+  "ws-restart"
+);
 
-// Watch for changes
-chokidar
-  .watch(join(__dirname, "..", "src", "Websocket", "**", "*"))
-  .on("change", (path: string) => {
-    const fileChanged = path.split("\\").pop();
-    console.log(`File changed: src/Lib/Websocket/${fileChanged}`);
-    restartServer();
-  });
+// Watch ./src recursively; restart on code/data file changes
+createSrcWatcher(SRC_DIR, {
+  exts: [".php", ".ts", ".js", ".json"],
+  onEvent: (ev, _abs, rel) => restarter.schedule(`${ev}: ${rel}`),
+  awaitWriteFinish: DEFAULT_AWF,
+  logPrefix: "WS watch",
+  usePolling: true,
+  interval: 1000,
+});
+
+// Graceful shutdown
+onExit(async () => {
+  await ws.stop();
+});

package/dist/settings/utils.ts

@@ -1,5 +1,8 @@
 import { fileURLToPath } from "url";
 import { dirname } from "path";
+import chokidar, { FSWatcher } from "chokidar";
+import { spawn, ChildProcess, execFile } from "child_process";
+import { relative } from "path";
 
 /**
  * Retrieves the file metadata including the filename and directory name.
@@ -12,3 +15,240 @@ export function getFileMeta() {
   const __dirname = dirname(__filename);
   return { __filename, __dirname };
 }
+
+export type WatchEvent = "add" | "addDir" | "change" | "unlink" | "unlinkDir";
+
+export const DEFAULT_IGNORES: (string | RegExp)[] = [
+  /(^|[\/\\])\../, // dotfiles
+  "**/node_modules/**",
+  "**/vendor/**",
+  "**/dist/**",
+  "**/build/**",
+  "**/.cache/**",
+  "**/*.log",
+  "**/*.tmp",
+  "**/*.swp",
+];
+
+export const DEFAULT_AWF = { stabilityThreshold: 300, pollInterval: 100 };
+
+/**
+ * Create a chokidar watcher for a given root. Optionally filter by file extensions.
+ */
+export function createSrcWatcher(
+  root: string,
+  opts: {
+    exts?: string[]; // e.g. ['.php','.ts']
+    onEvent: (event: WatchEvent, absPath: string, relPath: string) => void;
+    ignored?: (string | RegExp)[];
+    awaitWriteFinish?: { stabilityThreshold: number; pollInterval: number };
+    logPrefix?: string;
+    usePolling?: boolean;
+    interval?: number;
+  }
+): FSWatcher {
+  const {
+    exts,
+    onEvent,
+    ignored = DEFAULT_IGNORES,
+    awaitWriteFinish = DEFAULT_AWF,
+    logPrefix = "watch",
+    usePolling = true,
+  } = opts;
+
+  const watcher = chokidar.watch(root, {
+    ignoreInitial: true,
+    persistent: true,
+    ignored,
+    awaitWriteFinish,
+    usePolling,
+    interval: opts.interval ?? 1000,
+  });
+
+  watcher
+    .on("ready", () => {
+      console.log(`[${logPrefix}] Watching ${root.replace(/\\/g, "/")}/**/*`);
+    })
+    .on("all", (event: WatchEvent, filePath: string) => {
+      // Optional extension filter
+      if (exts && exts.length > 0) {
+        const ok = exts.some((ext) => filePath.endsWith(ext));
+        if (!ok) return;
+      }
+      const rel = relative(root, filePath).replace(/\\/g, "/");
+      if (event === "add" || event === "change" || event === "unlink") {
+        onEvent(event, filePath, rel);
+      }
+    })
+    .on("error", (err) => console.error(`[${logPrefix}] Error:`, err));
+
+  return watcher;
+}
+
+/**
+ * Debounced worker that ensures only one run at a time; extra runs get queued once.
+ */
+export class DebouncedWorker {
+  private timer: NodeJS.Timeout | null = null;
+  private running = false;
+  private queued = false;
+
+  constructor(
+    private work: () => Promise<void> | void,
+    private debounceMs = 350,
+    private name = "worker"
+  ) {}
+
+  schedule(reason?: string) {
+    if (reason) console.log(`[${this.name}] ${reason} → scheduled`);
+    if (this.timer) clearTimeout(this.timer);
+    this.timer = setTimeout(() => {
+      this.timer = null;
+      this.runNow().catch(() => {});
+    }, this.debounceMs);
+  }
+
+  private async runNow() {
+    if (this.running) {
+      this.queued = true;
+      return;
+    }
+    this.running = true;
+    try {
+      await this.work();
+    } catch (err) {
+      console.error(`[${this.name}] error:`, err);
+    } finally {
+      this.running = false;
+      if (this.queued) {
+        this.queued = false;
+        this.runNow().catch(() => {});
+      }
+    }
+  }
+}
+
+/**
+ * Cross-platform restartable process.
+ */
+export function createRestartableProcess(spec: {
+  name: string;
+  cmd: string;
+  args?: string[];
+  stdio?: "inherit" | [any, any, any];
+  gracefulSignal?: NodeJS.Signals;
+  forceKillAfterMs?: number;
+  windowsKillTree?: boolean;
+  onStdout?: (buf: Buffer) => void;
+  onStderr?: (buf: Buffer) => void;
+}) {
+  const {
+    name,
+    cmd,
+    args = [],
+    stdio = ["ignore", "pipe", "pipe"],
+    gracefulSignal = "SIGINT",
+    forceKillAfterMs = 2000,
+    windowsKillTree = true,
+    onStdout,
+    onStderr,
+  } = spec;
+
+  let child: ChildProcess | null = null;
+
+  function start() {
+    console.log(`[${name}] Starting: ${cmd} ${args.join(" ")}`.trim());
+    child = spawn(cmd, args, { stdio, windowsHide: true });
+
+    child.stdout?.on("data", (buf: Buffer) => {
+      if (onStdout) onStdout(buf);
+      else process.stdout.write(`[${name}] ${buf.toString()}`);
+    });
+
+    child.stderr?.on("data", (buf: Buffer) => {
+      if (onStderr) onStderr(buf);
+      else process.stderr.write(`[${name}:err] ${buf.toString()}`);
+    });
+
+    child.on("close", (code) => {
+      console.log(`[${name}] Exited with code ${code}`);
+    });
+
+    child.on("error", (err) => {
+      console.error(`[${name}] Failed to start:`, err);
+    });
+
+    return child;
+  }
+
+  function killOnWindows(pid: number): Promise<void> {
+    return new Promise((resolve) => {
+      const cp = execFile("taskkill", ["/F", "/T", "/PID", String(pid)], () =>
+        resolve()
+      );
+      cp.on("error", () => resolve());
+    });
+  }
+
+  async function stop(): Promise<void> {
+    if (!child || child.killed) return;
+    const pid = child.pid!;
+    console.log(`[${name}] Stopping…`);
+
+    if (process.platform === "win32" && windowsKillTree) {
+      await killOnWindows(pid);
+      child = null;
+      return;
+    }
+
+    await new Promise<void>((resolve) => {
+      const done = () => resolve();
+      child!.once("close", done).once("exit", done).once("disconnect", done);
+      try {
+        child!.kill(gracefulSignal);
+      } catch {
+        resolve();
+      }
+      setTimeout(() => {
+        if (child && !child.killed) {
+          try {
+            process.kill(pid, "SIGKILL");
+          } catch {}
+        }
+      }, forceKillAfterMs);
+    });
+    child = null;
+  }
+
+  async function restart(reason?: string) {
+    if (reason) console.log(`[${name}] Restart requested: ${reason}`);
+    await stop();
+    return start();
+  }
+
+  function getChild() {
+    return child;
+  }
+
+  return { start, stop, restart, getChild };
+}
+
+/**
+ * Register shutdown cleanup callbacks.
+ */
+export function onExit(fn: () => Promise<void> | void) {
+  const wrap = (sig: string) => async () => {
+    console.log(`[proc] Received ${sig}, shutting down…`);
+    try {
+      await fn();
+    } finally {
+      process.exit(0);
+    }
+  };
+  process.on("SIGINT", wrap("SIGINT"));
+  process.on("SIGTERM", wrap("SIGTERM"));
+  process.on("uncaughtException", async (err) => {
+    console.error("[proc] Uncaught exception:", err);
+    await wrap("uncaughtException")();
+  });
+}

package/dist/src/Lib/MCP/WeatherTools.php

@@ -0,0 +1,104 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Lib\MCP;
+
+use GuzzleHttp\Client;
+use GuzzleHttp\Exception\GuzzleException;
+use PhpMcp\Server\Attributes\McpTool;
+use PhpMcp\Server\Attributes\Schema;
+use RuntimeException;
+use JsonException;
+
+final class WeatherTools
+{
+    #[McpTool(
+        name: 'get-weathers',
+        description: 'Returns current temperature for a city'
+    )]
+    public function getWeather(
+        #[Schema(type: 'string', minLength: 1, description: 'City name')]
+        string $city
+    ): string {
+        $http = new Client([
+            'timeout'         => 10,
+            'connect_timeout' => 8,
+            'http_errors'     => true,
+            'headers'         => ['Accept' => 'application/json'],
+        ]);
+
+        try {
+            $geoUrl = 'https://geocoding-api.open-meteo.com/v1/search'
+                . '?name=' . rawurlencode($city)
+                . '&count=1&language=en&format=json';
+
+            $geoRes = $http->get($geoUrl);
+            $geoJson = $geoRes->getBody()->getContents();
+            $geo = json_decode($geoJson, true, 512, JSON_THROW_ON_ERROR);
+
+            if (empty($geo['results'][0])) {
+                throw new RuntimeException("City \"$city\" not found (geocoding returned no results).");
+            }
+
+            $lat = (float) $geo['results'][0]['latitude'];
+            $lon = (float) $geo['results'][0]['longitude'];
+
+            $wxUrl = "https://api.open-meteo.com/v1/forecast?latitude={$lat}&longitude={$lon}&current_weather=true";
+
+            $wxRes = $http->get($wxUrl);
+            $wxJson = $wxRes->getBody()->getContents();
+            $wx = json_decode($wxJson, true, 512, JSON_THROW_ON_ERROR);
+
+            $cw = $wx['current_weather'] ?? null;
+            if (!is_array($cw)) {
+                throw new RuntimeException('No current weather data found in API response.');
+            }
+
+            $map = [
+                0 => 'Clear sky',
+                1 => 'Mainly clear',
+                2 => 'Partly cloudy',
+                3 => 'Overcast',
+                45 => 'Fog',
+                48 => 'Depositing rime fog',
+                51 => 'Light drizzle',
+                53 => 'Moderate drizzle',
+                55 => 'Dense drizzle',
+                56 => 'Light freezing drizzle',
+                57 => 'Dense freezing drizzle',
+                61 => 'Slight rain',
+                63 => 'Moderate rain',
+                65 => 'Heavy rain',
+                66 => 'Light freezing rain',
+                67 => 'Heavy freezing rain',
+                71 => 'Slight snow fall',
+                73 => 'Moderate snow fall',
+                75 => 'Heavy snow fall',
+                77 => 'Snow grains',
+                80 => 'Slight rain showers',
+                81 => 'Moderate rain showers',
+                82 => 'Violent rain showers',
+                85 => 'Slight snow showers',
+                86 => 'Heavy snow showers',
+                95 => 'Thunderstorm',
+                96 => 'Thunderstorm with slight hail',
+                99 => 'Thunderstorm with heavy hail',
+            ];
+
+            $code  = (int)($cw['weathercode'] ?? -1);
+            $tempC = $cw['temperature'] ?? null;
+
+            if (!is_numeric($tempC)) {
+                throw new RuntimeException('Temperature missing or not numeric in current weather payload.');
+            }
+
+            $desc = $map[$code] ?? 'Unknown';
+            return "🌡️ {$tempC} °C · {$desc} (code {$code})";
+        } catch (GuzzleException $e) {
+            throw new RuntimeException('Weather request failed: ' . $e->getMessage(), previous: $e);
+        } catch (JsonException $e) {
+            throw new RuntimeException('Weather JSON parsing failed: ' . $e->getMessage(), previous: $e);
+        }
+    }
+}

package/dist/src/Lib/MCP/mcp-server.php

@@ -0,0 +1,80 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Lib\MCP;
+
+$root = dirname(__DIR__, 3);
+require $root . '/vendor/autoload.php';
+require $root . '/settings/paths.php';
+
+use Dotenv\Dotenv;
+use PhpMcp\Server\Server;
+use PhpMcp\Server\Transports\StreamableHttpServerTransport;
+use Throwable;
+
+// ── Load .env (optional) and timezone ──────────────────────────────────────────
+if (file_exists(DOCUMENT_PATH . '/.env')) {
+    Dotenv::createImmutable(DOCUMENT_PATH)->safeLoad();
+}
+date_default_timezone_set($_ENV['APP_TIMEZONE'] ?? 'UTC');
+
+// ── Resolve settings (with sane defaults) ─────────────────────────────────────
+$appName    = $_ENV['MCP_NAME']         ?? 'prisma-php-mcp';
+$appVersion = $_ENV['MCP_VERSION']      ?? '0.0.1';
+$host       = $_ENV['MCP_HOST']         ?? '127.0.0.1';
+$port       = (int)($_ENV['MCP_PORT']   ?? 4000);
+$prefix     = trim($_ENV['MCP_PATH_PREFIX'] ?? 'mcp', '/');
+$enableJson = filter_var($_ENV['MCP_JSON_RESPONSE'] ?? 'false', FILTER_VALIDATE_BOOLEAN);
+
+// ── Build server and discover tools ───────────────────────────────────────────
+$server = Server::make()
+    ->withServerInfo($appName, $appVersion)
+    ->build();
+
+// Scan your source tree for #[McpTool] classes
+$server->discover(DOCUMENT_PATH, ['src']);
+
+// ── Pretty console output ─────────────────────────────────────────────────────
+$pid    = getmypid() ?: 0;
+$base   = "http://{$host}:{$port}/{$prefix}";
+$color  = static fn(string $t, string $c) => "\033[{$c}m{$t}\033[0m";
+
+echo PHP_EOL;
+echo $color("⚙  {$appName} (v{$appVersion})", '1;36') . PHP_EOL;
+echo $color("→ MCP server starting…", '33') . PHP_EOL;
+echo "   Host:       {$host}" . PHP_EOL;
+echo "   Port:       {$port}" . PHP_EOL;
+echo "   Path:       /{$prefix}" . PHP_EOL;
+echo "   JSON resp:  " . ($enableJson ? 'enabled' : 'disabled') . PHP_EOL;
+echo "   PID:        {$pid}" . PHP_EOL;
+echo "   URL:        {$base}" . PHP_EOL;
+
+// ── Graceful shutdown (if pcntl is available) ─────────────────────────────────
+if (function_exists('pcntl_signal')) {
+    $stop = function (int $sig) use ($color) {
+        echo PHP_EOL . $color("⏹  Caught signal {$sig}. Shutting down…", '33') . PHP_EOL;
+        exit(0);
+    };
+    pcntl_signal(SIGINT,  $stop);
+    pcntl_signal(SIGTERM, $stop);
+}
+
+// ── Listen ────────────────────────────────────────────────────────────────────
+try {
+    $transport = new StreamableHttpServerTransport(
+        $host,
+        $port,
+        $prefix,
+        null,            // sslContext
+        true,            // logger
+        $enableJson      // enableJsonResponse
+        // , false        // (optional) stateless
+    );
+    echo $color("✓ Listening on {$base}", '32') . PHP_EOL;
+    $server->listen($transport);
+    echo PHP_EOL . $color('✔ Server stopped.', '32') . PHP_EOL;
+} catch (Throwable $e) {
+    fwrite(STDERR, $color('✖ Server error: ', '31') . $e->getMessage() . PHP_EOL);
+    exit(1);
+}

package/dist/src/Lib/Middleware/AuthMiddleware.php

@@ -12,6 +12,9 @@ final class AuthMiddleware
 {
     public static function handle($requestPathname)
     {
+        $singInRoute = "/signin";
+        $deniedRoute = "/denied";
+
         if (AuthConfig::IS_ALL_ROUTES_PRIVATE) {
             $isLogin = Auth::getInstance()->isAuthenticated();
             $isApiAuthRoute = stripos($requestPathname, AuthConfig::API_AUTH_PREFIX) === 0;
@@ -42,7 +45,7 @@ final class AuthMiddleware
 
             // Redirect to the default home route if the user is already authenticated
             if (!$isLogin && !$isPublicRoute) {
-                Request::redirect("/signin");
+                Request::redirect($singInRoute);
             }
         } else {
             // Skip the middleware if the route is public
@@ -52,7 +55,7 @@ final class AuthMiddleware
 
             // Check if the user is authorized to access the route or redirect to login
             if (!self::isAuthorized()) {
-                Request::redirect('/signin');
+                Request::redirect($singInRoute);
             }
         }
 
@@ -65,7 +68,7 @@ final class AuthMiddleware
                 // echo "You are authorized to access this route";
             } elseif ($matchValue === "Role mismatch") {
                 // echo "You are not authorized to access this route";
-                Request::redirect('/denied');
+                Request::redirect($deniedRoute);
             } else {
                 // echo "Unexpected error encountered";
             }